@ukiahinsure/a2ui-react-adapter 0.1.0

package/dist/index.js

@@ -0,0 +1,2854 @@
+import {
+  A2UI_CAPABILITIES_TOPIC,
+  A2UI_CLIENT_TOPIC,
+  A2UI_PROTOCOL_VERSION,
+  A2UI_SERVER_TOPIC,
+  CLIENT_ACTIONS,
+  CLIENT_ERROR_CODES,
+  ENVELOPE_VERSION,
+  MAX_ENVELOPE_BYTES
+} from "./chunk-AOBRTDAU.js";
+
+// src/adapter.ts
+import { basicCatalog } from "@a2ui/react/v0_9";
+import {
+  A2uiError,
+  A2uiMessageListSchema,
+  MessageProcessor
+} from "@a2ui/web_core/v0_9";
+var RENDERER_NAME = "a2ui_react_adapter";
+var RENDERER_VERSION = "0.1.0";
+var A2UIClientAdapter = class {
+  rendererName = RENDERER_NAME;
+  rendererVersion = RENDERER_VERSION;
+  #processor;
+  #options;
+  #listeners = /* @__PURE__ */ new Set();
+  #actionListeners = /* @__PURE__ */ new Set();
+  #errorListeners = /* @__PURE__ */ new Set();
+  #surfaceOrder = [];
+  #structureBySurface = /* @__PURE__ */ new Map();
+  #version = 0;
+  #lastSeq = 0;
+  #disposed = false;
+  constructor(options = {}) {
+    this.#options = options;
+    this.#processor = this.#createProcessor();
+  }
+  /** Catalog ids this adapter will announce in capability envelopes. */
+  get supportedCatalogIds() {
+    return [basicCatalog.id];
+  }
+  get lastSeq() {
+    return this.#lastSeq;
+  }
+  /** The most recently created live surface, if any. */
+  get currentSurface() {
+    const id = this.#surfaceOrder[this.#surfaceOrder.length - 1];
+    return id === void 0 ? void 0 : this.getSurface(id);
+  }
+  getSurface(id) {
+    return this.#processor.model.getSurface(id);
+  }
+  /** Immutable value-free structure for host accessibility augmentation. */
+  getSurfaceStructure(id) {
+    const structure = this.#structureBySurface.get(id);
+    if (structure === void 0) {
+      return { fields: [], tabs: [] };
+    }
+    return {
+      fields: [...structure.fieldsByComponent.values()].map((field) => ({
+        ...field
+      })),
+      tabs: [...structure.tabsByComponent.values()].flat().map((tab) => ({ ...tab }))
+    };
+  }
+  /** Read a complete scalar field set without exposing the SDK data model. */
+  getFieldValues(surfaceId, fields) {
+    const surface = this.#processor.model.getSurface(surfaceId);
+    if (surface === void 0) {
+      return null;
+    }
+    const values = {};
+    for (const field of fields) {
+      const value = surface.dataModel.get(fieldPointer(field));
+      if (!isFieldValue(value)) {
+        return null;
+      }
+      values[field] = value;
+    }
+    return values;
+  }
+  /** Restore a private draft after a trusted processor replacement. */
+  applyFieldValues(surfaceId, values) {
+    const surface = this.#processor.model.getSurface(surfaceId);
+    if (surface === void 0) {
+      return false;
+    }
+    let changed = false;
+    for (const [field, value] of Object.entries(values)) {
+      const path = fieldPointer(field);
+      if (!Object.is(surface.dataModel.get(path), value)) {
+        surface.dataModel.set(path, value);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.#notify();
+    }
+    return true;
+  }
+  /**
+   * Apply one validated server envelope. Returns false for duplicates and
+   * out-of-order deliveries (the per-session `seq` guard) and for envelopes
+   * that fail to apply; committed surfaces are never partially replaced.
+   */
+  applyServerEnvelope(envelope) {
+    if (this.#disposed) {
+      return false;
+    }
+    if (envelope.seq <= this.#lastSeq) {
+      return false;
+    }
+    this.#lastSeq = envelope.seq;
+    if (envelope.kind === "ack") {
+      this.#options.onAck?.(envelope);
+      return true;
+    }
+    return this.#applySurfaceEnvelope(envelope);
+  }
+  /**
+   * Reset the ordering guard; used when a reconnect snapshot restarts the
+   * server sequence (Queue-Item 024-004).
+   */
+  resetSequence() {
+    this.#lastSeq = 0;
+  }
+  /** Clear every generated surface without disposing the reusable adapter. */
+  clearSurfaces() {
+    if (this.#disposed) {
+      return;
+    }
+    const replacement = this.#createProcessor();
+    const previous = this.#processor;
+    this.#processor = replacement;
+    this.#surfaceOrder = [];
+    this.#structureBySurface.clear();
+    previous.model.dispose();
+    this.#notify();
+  }
+  /** Emit one of the locked, body-free client error events. */
+  reportClientError(errorCode, surfaceId, detail) {
+    if (this.#disposed) {
+      return;
+    }
+    const event = { errorCode, surfaceId, detail };
+    this.#options.onClientError?.(event);
+    for (const listener of this.#errorListeners) {
+      listener(event);
+    }
+  }
+  /** Report a rendering failure (used by the surface host error boundary). */
+  reportRenderFailure(surfaceId, detail) {
+    this.reportClientError("render_failed", surfaceId, detail);
+  }
+  subscribe = (listener) => {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  };
+  subscribeActions = (listener) => {
+    this.#actionListeners.add(listener);
+    return () => this.#actionListeners.delete(listener);
+  };
+  subscribeClientErrors = (listener) => {
+    this.#errorListeners.add(listener);
+    return () => this.#errorListeners.delete(listener);
+  };
+  /** Monotonic change counter for `useSyncExternalStore`. */
+  getVersion = () => this.#version;
+  dispose() {
+    if (this.#disposed) {
+      return;
+    }
+    this.#disposed = true;
+    this.#processor.model.dispose();
+    this.#structureBySurface.clear();
+    this.#listeners.clear();
+    this.#actionListeners.clear();
+    this.#errorListeners.clear();
+  }
+  #applySurfaceEnvelope(envelope) {
+    const validated = A2uiMessageListSchema.safeParse(envelope.messages);
+    if (!validated.success) {
+      this.reportClientError(
+        "message_malformed",
+        envelope.surfaceId,
+        "message_schema_invalid"
+      );
+      return false;
+    }
+    const candidate = this.#createProcessor();
+    try {
+      if (envelope.kind !== "snapshot") {
+        candidate.processMessages(this.#snapshotMessages());
+      }
+      candidate.processMessages(validated.data);
+    } catch (error) {
+      candidate.model.dispose();
+      this.reportClientError(
+        classifyProcessingError(error),
+        envelope.surfaceId,
+        error instanceof A2uiError ? error.code : "processing_failed"
+      );
+      return false;
+    }
+    const previous = this.#processor;
+    const nextStructure = updateSurfaceStructures(
+      validated.data,
+      envelope.kind === "snapshot" ? /* @__PURE__ */ new Map() : cloneSurfaceStructures(this.#structureBySurface)
+    );
+    pruneSurfaceStructures(nextStructure, candidate);
+    if (!fieldInteractionBindingsTrusted(
+      envelope.fieldInteractions ?? [],
+      nextStructure.get(envelope.surfaceId)
+    )) {
+      candidate.model.dispose();
+      this.reportClientError(
+        "message_malformed",
+        envelope.surfaceId,
+        "field_interaction_untrusted"
+      );
+      return false;
+    }
+    this.#processor = candidate;
+    this.#surfaceOrder = [...candidate.model.surfacesMap.keys()];
+    this.#structureBySurface = nextStructure;
+    previous.model.dispose();
+    this.#notify();
+    return true;
+  }
+  #createProcessor() {
+    return new MessageProcessor(
+      [basicCatalog],
+      (action) => this.#emitAction(action)
+    );
+  }
+  #emitAction(action) {
+    if (!isRecord(action) || !isNonEmptyString(action.name) || !isNonEmptyString(action.surfaceId) || !isNonEmptyString(action.sourceComponentId) || !isRecord(action.context)) {
+      this.reportClientError(
+        "message_malformed",
+        void 0,
+        "renderer_action_invalid"
+      );
+      return;
+    }
+    const event = {
+      actionName: action.name,
+      surfaceId: action.surfaceId,
+      sourceComponentId: action.sourceComponentId,
+      context: { ...action.context }
+    };
+    this.#options.onAction?.(event);
+    for (const listener of this.#actionListeners) {
+      listener(event);
+    }
+  }
+  #snapshotMessages() {
+    const messages = [];
+    for (const surface of this.#processor.model.surfacesMap.values()) {
+      messages.push({
+        version: "v0.9",
+        createSurface: {
+          surfaceId: surface.id,
+          catalogId: surface.catalog.id,
+          theme: surface.theme,
+          sendDataModel: surface.sendDataModel
+        }
+      });
+      const components = [...surface.componentsModel.entries].map(
+        ([id, component]) => ({
+          id,
+          component: component.type,
+          ...component.properties
+        })
+      );
+      if (components.length > 0) {
+        messages.push({
+          version: "v0.9",
+          updateComponents: { surfaceId: surface.id, components }
+        });
+      }
+      const data = surface.dataModel.get("/");
+      if (data !== void 0) {
+        messages.push({
+          version: "v0.9",
+          updateDataModel: { surfaceId: surface.id, path: "/", value: data }
+        });
+      }
+    }
+    return messages;
+  }
+  #notify() {
+    this.#version += 1;
+    for (const listener of this.#listeners) {
+      listener();
+    }
+  }
+};
+function emptySurfaceStructure() {
+  return {
+    fieldsByComponent: /* @__PURE__ */ new Map(),
+    tabsByComponent: /* @__PURE__ */ new Map()
+  };
+}
+function cloneSurfaceStructures(source) {
+  return new Map(
+    [...source].map(([surfaceId, structure]) => [
+      surfaceId,
+      {
+        fieldsByComponent: new Map(
+          [...structure.fieldsByComponent].map(([id, field]) => [
+            id,
+            { ...field }
+          ])
+        ),
+        tabsByComponent: new Map(
+          [...structure.tabsByComponent].map(([id, tabs]) => [
+            id,
+            tabs.map((tab) => ({ ...tab }))
+          ])
+        )
+      }
+    ])
+  );
+}
+function updateSurfaceStructures(messages, structures) {
+  for (const message of messages) {
+    if (!isRecord(message)) {
+      continue;
+    }
+    const deletion = message.deleteSurface;
+    if (isRecord(deletion) && isNonEmptyString(deletion.surfaceId)) {
+      structures.delete(deletion.surfaceId);
+      continue;
+    }
+    const creation = message.createSurface;
+    if (isRecord(creation) && isNonEmptyString(creation.surfaceId)) {
+      structures.set(creation.surfaceId, emptySurfaceStructure());
+    }
+    const update = message.updateComponents;
+    if (!isRecord(update) || !isNonEmptyString(update.surfaceId) || !Array.isArray(update.components)) {
+      continue;
+    }
+    const structure = structures.get(update.surfaceId) ?? emptySurfaceStructure();
+    structures.set(update.surfaceId, structure);
+    for (const component of update.components) {
+      if (!isRecord(component) || !isNonEmptyString(component.id)) {
+        continue;
+      }
+      structure.fieldsByComponent.delete(component.id);
+      structure.tabsByComponent.delete(component.id);
+      const field = fieldDescriptor(component);
+      if (field !== void 0) {
+        structure.fieldsByComponent.set(component.id, field);
+      }
+      const tabs = tabDescriptors(component);
+      if (tabs.length > 0) {
+        structure.tabsByComponent.set(component.id, tabs);
+      }
+    }
+  }
+  return structures;
+}
+function pruneSurfaceStructures(structures, processor) {
+  for (const [surfaceId, structure] of structures) {
+    const surface = processor.model.getSurface(surfaceId);
+    if (surface === void 0) {
+      structures.delete(surfaceId);
+      continue;
+    }
+    const componentIds = new Set(
+      [...surface.componentsModel.entries].map(([componentId]) => componentId)
+    );
+    for (const componentId of structure.fieldsByComponent.keys()) {
+      if (!componentIds.has(componentId)) {
+        structure.fieldsByComponent.delete(componentId);
+      }
+    }
+    for (const componentId of structure.tabsByComponent.keys()) {
+      if (!componentIds.has(componentId)) {
+        structure.tabsByComponent.delete(componentId);
+      }
+    }
+  }
+}
+function fieldInteractionBindingsTrusted(groups, structure) {
+  if (groups.length === 0) {
+    return true;
+  }
+  if (structure === void 0) {
+    return false;
+  }
+  return groups.every(
+    (group) => group.fields.every((binding) => {
+      const field = structure.fieldsByComponent.get(binding.componentId);
+      return field?.field === binding.field;
+    })
+  );
+}
+function fieldDescriptor(component) {
+  const controls = {
+    TextField: "text",
+    DateTimeInput: "date",
+    ChoicePicker: "choice"
+  };
+  const control = typeof component.component === "string" ? controls[component.component] : void 0;
+  const value = component.value;
+  const field = isRecord(value) && typeof value.path === "string" ? fieldFromPointer(value.path) : void 0;
+  if (control === void 0 || field === void 0 || !isNonEmptyString(component.id)) {
+    return void 0;
+  }
+  return {
+    componentId: component.id,
+    field,
+    label: typeof component.label === "string" && component.label.length > 0 ? component.label : field,
+    control,
+    required: hasRequiredCheck(component.checks)
+  };
+}
+function hasRequiredCheck(value) {
+  return Array.isArray(value) && value.some(
+    (check) => isRecord(check) && isRecord(check.condition) && check.condition.call === "required"
+  );
+}
+function fieldFromPointer(path) {
+  if (!path.startsWith("/") || path.length < 2 || path.slice(1).includes("/")) {
+    return void 0;
+  }
+  return path.slice(1).replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function fieldPointer(field) {
+  return `/${field.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+}
+function isFieldValue(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function tabDescriptors(component) {
+  if (component.component !== "Tabs" || !isNonEmptyString(component.id) || !Array.isArray(component.tabs)) {
+    return [];
+  }
+  const tabs = [];
+  for (const tab of component.tabs) {
+    if (isRecord(tab) && isNonEmptyString(tab.title) && isNonEmptyString(tab.child)) {
+      tabs.push({
+        componentId: component.id,
+        title: tab.title,
+        childId: tab.child
+      });
+    }
+  }
+  return tabs;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function classifyProcessingError(error) {
+  if (error instanceof A2uiError && typeof error.message === "string" && error.message.startsWith("Catalog not found")) {
+    return "catalog_unsupported";
+  }
+  return "message_malformed";
+}
+
+// src/SurfaceHost.tsx
+import {
+  Component,
+  useId,
+  useLayoutEffect,
+  useRef,
+  useSyncExternalStore
+} from "react";
+import { A2uiSurface } from "@a2ui/react/v0_9";
+import { jsx } from "react/jsx-runtime";
+function A2UISurfaceHost({
+  adapter,
+  surfaceId,
+  surfaceMetadata,
+  sessionController,
+  hostId,
+  ariaLabel = "Current intake step",
+  disabled = false,
+  busy = false,
+  invalidFields = [],
+  validationSummaryId,
+  noSurfaceFallback,
+  errorFallback
+}) {
+  const version = useSyncExternalStore(
+    adapter.subscribe,
+    adapter.getVersion,
+    adapter.getVersion
+  );
+  const readSessionSnapshot = sessionController?.getSnapshot ?? getNoSessionSnapshot;
+  const subscribeSession = sessionController?.subscribe ?? subscribeToNothing;
+  const controllerSnapshot = useSyncExternalStore(
+    subscribeSession,
+    readSessionSnapshot,
+    readSessionSnapshot
+  );
+  const generatedId = useId().replaceAll(":", "");
+  const rootRef = useRef(null);
+  const lastFocusedState = useRef(void 0);
+  const lastViewedSection = useRef(void 0);
+  const lastValidationKey = useRef("");
+  const resolvedSurfaceMetadata = surfaceMetadata ?? controllerSnapshot?.surface ?? null;
+  const editing = controllerSnapshot?.editing ?? editingForSurface(resolvedSurfaceMetadata);
+  const surface = surfaceId === void 0 ? adapter.currentSurface : adapter.getSurface(surfaceId);
+  const structure = surface === void 0 ? EMPTY_STRUCTURE : adapter.getSurfaceStructure(surface.id);
+  const focusKey = surface === void 0 ? void 0 : `${surface.id}:${resolvedSurfaceMetadata?.activeStateId ?? "surface"}`;
+  const frameId = hostId ?? `a2ui-surface-${generatedId}`;
+  useLayoutEffect(() => {
+    const root = rootRef.current;
+    if (root === null || surface === void 0) {
+      return;
+    }
+    let cancelled = false;
+    let controlCleanups = [];
+    const refreshControls = () => {
+      if (cancelled || !root.isConnected) {
+        return;
+      }
+      for (const cleanup of controlCleanups.reverse()) {
+        cleanup();
+      }
+      controlCleanups = [
+        annotateFields(
+          root,
+          structure.fields,
+          new Set(invalidFields),
+          validationSummaryId
+        ),
+        formatFieldLabels(root),
+        bindFieldInteractionGroups(
+          root,
+          resolvedSurfaceMetadata?.fieldInteractions ?? [],
+          editing,
+          sessionController
+        ),
+        hideGeneratedGroupLabels(
+          root,
+          resolvedSurfaceMetadata?.fieldInteractions ?? []
+        ),
+        annotateActionControls(root),
+        setPendingGroupsDisabled(
+          root,
+          new Set(editing.pendingGroupIds)
+        ),
+        setInteractionDisabled(root, disabled || busy)
+      ];
+    };
+    const scheduleControlRefresh = () => {
+      queueMicrotask(refreshControls);
+    };
+    const tabCleanup = enhanceTabs(
+      root,
+      structure.tabs,
+      resolvedSurfaceMetadata?.sectionNavigation ?? null,
+      editing.viewedSectionId,
+      frameId,
+      scheduleControlRefresh,
+      (sectionId) => sessionController?.viewSection(sectionId)
+    );
+    scheduleControlRefresh();
+    const previousViewedSection = lastViewedSection.current;
+    const authoritativeSection = editing.authoritativeSectionId;
+    const hasRetainedEdit = editing.dirtyGroupIds.length > 0 || editing.pendingGroupIds.length > 0 || editing.rejectedGroupIds.length > 0;
+    const authoritativeStateChanged = focusKey !== void 0 && lastFocusedState.current !== focusKey;
+    const returnedToCurrent = previousViewedSection !== void 0 && previousViewedSection !== authoritativeSection && editing.viewedSectionId === authoritativeSection;
+    const validationKey = invalidFields.length === 0 ? "" : `${controllerSnapshot?.actions.lastResult?.requestId ?? "fields"}:${invalidFields.join("\0")}`;
+    const validationChanged = validationKey.length > 0 && validationKey !== lastValidationKey.current;
+    lastFocusedState.current = focusKey;
+    lastViewedSection.current = editing.viewedSectionId;
+    lastValidationKey.current = validationKey;
+    if (validationChanged && validationSummaryId === void 0 || returnedToCurrent || authoritativeStateChanged && !hasRetainedEdit && editing.viewedSectionId === authoritativeSection) {
+      queueMicrotask(() => {
+        refreshControls();
+        if (cancelled || !root.isConnected) {
+          return;
+        }
+        focusProgressTarget(
+          root,
+          resolvedSurfaceMetadata,
+          invalidFields
+        );
+      });
+    }
+    return () => {
+      cancelled = true;
+      for (const cleanup of controlCleanups.reverse()) {
+        cleanup();
+      }
+      tabCleanup();
+    };
+  }, [
+    busy,
+    disabled,
+    editing,
+    focusKey,
+    frameId,
+    invalidFields,
+    structure,
+    surface,
+    resolvedSurfaceMetadata,
+    sessionController,
+    controllerSnapshot?.actions.lastResult?.requestId,
+    validationSummaryId,
+    version
+  ]);
+  if (surface === void 0) {
+    return noSurfaceFallback ?? /* @__PURE__ */ jsx("div", { "data-a2ui-host": "no-surface", role: "status", "aria-live": "polite", children: "Your conversation continues by voice." });
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: rootRef,
+      id: frameId,
+      className: "a2ui-accessible-surface",
+      "data-a2ui-host": "surface",
+      "data-a2ui-disabled": disabled || busy ? "true" : "false",
+      role: "region",
+      "aria-label": ariaLabel,
+      "aria-busy": busy || void 0,
+      "aria-disabled": disabled || busy || void 0,
+      tabIndex: -1,
+      children: /* @__PURE__ */ jsx(
+        SurfaceErrorBoundary,
+        {
+          adapter,
+          surface,
+          fallback: errorFallback ?? /* @__PURE__ */ jsx("div", { "data-a2ui-host": "render-error", role: "alert", children: "This step can't be shown right now. Please continue by voice." }),
+          children: /* @__PURE__ */ jsx(A2uiSurface, { surface })
+        },
+        surface.id
+      )
+    }
+  );
+}
+function getNoSessionSnapshot() {
+  return null;
+}
+function subscribeToNothing() {
+  return () => void 0;
+}
+function editingForSurface(surface) {
+  const authoritative = surface?.sectionNavigation?.activeSectionId ?? null;
+  return {
+    authoritativeSectionId: authoritative,
+    viewedSectionId: authoritative,
+    dirtyGroupIds: [],
+    pendingGroupIds: [],
+    rejectedGroupIds: []
+  };
+}
+function focusProgressTarget(root, metadata, invalidFields) {
+  const controls = [
+    ...root.querySelectorAll("[data-a2ui-field]")
+  ].filter((control) => !isControlDisabled(control));
+  const invalid2 = invalidFields.map(
+    (field) => controls.find((control) => control.dataset.a2uiField === field)
+  ).find((control) => control !== void 0);
+  const currentFields = metadata?.fieldInteractions.find((group) => group.mode === "current")?.fields.map((binding) => binding.field) ?? [];
+  const current = currentFields.map(
+    (field) => controls.find((control) => control.dataset.a2uiField === field)
+  ).find((control) => control !== void 0);
+  const target = invalid2 ?? current ?? controls[0] ?? root;
+  target.focus({ preventScroll: true });
+  if (target !== root) {
+    target.scrollIntoView?.({
+      block: "nearest",
+      behavior: prefersReducedMotion() ? "auto" : "smooth"
+    });
+  }
+}
+function isControlDisabled(control) {
+  return control.getAttribute("aria-disabled") === "true" || "disabled" in control && control.disabled === true;
+}
+function prefersReducedMotion() {
+  return globalThis.matchMedia?.("(prefers-reduced-motion: reduce)").matches ?? false;
+}
+function bindFieldInteractionGroups(root, groups, editing, controller) {
+  if (groups.length === 0) {
+    return () => void 0;
+  }
+  const groupByField = new Map(
+    groups.flatMap(
+      (group) => group.fields.map(
+        (binding) => [binding.field, group]
+      )
+    )
+  );
+  const originalGroupAttributes = /* @__PURE__ */ new Map();
+  for (const control of root.querySelectorAll(
+    "[data-a2ui-field]"
+  )) {
+    const field = control.dataset.a2uiField;
+    const group = field === void 0 ? void 0 : groupByField.get(field);
+    if (group !== void 0) {
+      originalGroupAttributes.set(control, {
+        groupId: control.dataset.a2uiGroupId,
+        groupMode: control.dataset.a2uiGroupMode,
+        editState: control.dataset.a2uiEditState
+      });
+      control.dataset.a2uiGroupId = group.groupId;
+      control.dataset.a2uiGroupMode = group.mode;
+      control.dataset.a2uiEditState = groupEditState(group.groupId, editing);
+    }
+  }
+  if (controller === void 0) {
+    return () => {
+      restoreGroupAttributes(originalGroupAttributes);
+    };
+  }
+  const queuedCaptures = /* @__PURE__ */ new Set();
+  const scheduleCapture = (groupId) => {
+    if (queuedCaptures.has(groupId)) {
+      return;
+    }
+    queuedCaptures.add(groupId);
+    queueMicrotask(() => {
+      queuedCaptures.delete(groupId);
+      controller.captureFieldGroupDraft(groupId);
+    });
+  };
+  const onInput = (event) => {
+    const groupId = interactionGroupId(root, event.target);
+    if (groupId !== void 0) {
+      scheduleCapture(groupId);
+    }
+  };
+  const onFocusOut = (event) => {
+    const groupId = interactionGroupId(root, event.target);
+    const group = groups.find((candidate) => candidate.groupId === groupId);
+    if (groupId === void 0 || group?.mode === "current" || interactionGroupId(root, event.relatedTarget) === groupId) {
+      return;
+    }
+    queueMicrotask(() => {
+      if (interactionGroupId(root, root.ownerDocument.activeElement) !== groupId) {
+        controller.commitFieldGroup(groupId);
+      }
+    });
+  };
+  root.addEventListener("input", onInput, true);
+  root.addEventListener("change", onInput, true);
+  root.addEventListener("focusout", onFocusOut, true);
+  return () => {
+    root.removeEventListener("input", onInput, true);
+    root.removeEventListener("change", onInput, true);
+    root.removeEventListener("focusout", onFocusOut, true);
+    restoreGroupAttributes(originalGroupAttributes);
+  };
+}
+function groupEditState(groupId, editing) {
+  if (editing.pendingGroupIds.includes(groupId)) {
+    return "saving";
+  }
+  if (editing.rejectedGroupIds.includes(groupId)) {
+    return "rejected";
+  }
+  return editing.dirtyGroupIds.includes(groupId) ? "dirty" : "saved";
+}
+function hideGeneratedGroupLabels(root, groups) {
+  if (groups.length === 0) {
+    return () => void 0;
+  }
+  const originals = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    const controls = [
+      ...root.querySelectorAll("[data-a2ui-group-id]")
+    ].filter((control) => control.dataset.a2uiGroupId === group.groupId);
+    const label = generatedGroupLabelForControls(root, controls);
+    if (label === void 0 || originals.has(label)) {
+      continue;
+    }
+    originals.set(label, {
+      hidden: label.hidden,
+      ariaHidden: label.getAttribute("aria-hidden"),
+      generatedGroupLabel: label.dataset.a2uiGeneratedGroupLabel
+    });
+    label.hidden = true;
+    label.setAttribute("aria-hidden", "true");
+    label.dataset.a2uiGeneratedGroupLabel = "true";
+  }
+  return () => {
+    for (const [label, original] of originals) {
+      label.hidden = original.hidden;
+      restoreAttribute(label, "aria-hidden", original.ariaHidden);
+      restoreDataset(
+        label,
+        "a2uiGeneratedGroupLabel",
+        original.generatedGroupLabel
+      );
+    }
+  };
+}
+function generatedGroupLabelForControls(root, controls) {
+  for (const control of controls) {
+    const label = generatedGroupLabelForControl(root, control);
+    if (label !== void 0) {
+      return label;
+    }
+  }
+  return void 0;
+}
+function generatedGroupLabelForControl(root, control) {
+  let current = control;
+  while (current !== null && current !== root) {
+    const parent = current.parentElement;
+    if (parent === null) {
+      return void 0;
+    }
+    const siblings = [...parent.children];
+    const currentIndex = siblings.indexOf(current);
+    const precedingText = siblings.slice(0, currentIndex).filter(isGeneratedTextElement);
+    if (precedingText.length >= 2) {
+      return precedingText[0];
+    }
+    if (precedingText.length === 1 && subtreeHasGeneratedTextElement(current)) {
+      return precedingText[0];
+    }
+    current = parent;
+  }
+  return void 0;
+}
+function subtreeHasGeneratedTextElement(element) {
+  return [...element.querySelectorAll("*")].some(isGeneratedTextElement);
+}
+function isGeneratedTextElement(element) {
+  return element instanceof HTMLElement && element.textContent?.trim() !== "" && element.querySelector("button, input, textarea, select, label") === null && (element.classList.contains("a2ui-text") || element.classList.contains("no-markdown-renderer") || ["h1", "h2", "h3", "h4", "h5", "body", "caption"].some(
+    (className) => element.classList.contains(className)
+  ) || element.querySelector(":scope > section > :is(h1, h2, h3, h4, h5, p)") !== null);
+}
+function restoreGroupAttributes(originals) {
+  for (const [control, original] of originals) {
+    restoreDataset(control, "a2uiGroupId", original.groupId);
+    restoreDataset(control, "a2uiGroupMode", original.groupMode);
+    restoreDataset(control, "a2uiEditState", original.editState);
+  }
+}
+function restoreDataset(element, key, value) {
+  if (value === void 0) {
+    delete element.dataset[key];
+  } else {
+    element.dataset[key] = value;
+  }
+}
+function interactionGroupId(root, target) {
+  if (!(target instanceof Element) || !root.contains(target)) {
+    return void 0;
+  }
+  return target.closest("[data-a2ui-group-id]")?.dataset.a2uiGroupId;
+}
+function annotateActionControls(root) {
+  const actions = [...root.querySelectorAll("button")].filter(
+    (button) => button.getAttribute("role") !== "tab" && ["submit", "skip", "revise"].includes(
+      button.textContent?.trim().toLowerCase() ?? ""
+    )
+  );
+  const groups = /* @__PURE__ */ new Set();
+  for (const action of actions) {
+    action.dataset.a2uiAction = "true";
+    if (action.parentElement !== null) {
+      action.parentElement.dataset.a2uiActionGroup = "true";
+      groups.add(action.parentElement);
+    }
+  }
+  return () => {
+    for (const action of actions) {
+      delete action.dataset.a2uiAction;
+    }
+    for (const group of groups) {
+      delete group.dataset.a2uiActionGroup;
+    }
+  };
+}
+var EMPTY_STRUCTURE = { fields: [], tabs: [] };
+var SurfaceErrorBoundary = class extends Component {
+  state = { failedSurfaceId: void 0 };
+  static getDerivedStateFromError() {
+    return { failedSurfaceId: "pending" };
+  }
+  componentDidCatch(error) {
+    this.setState({ failedSurfaceId: this.props.surface.id });
+    this.props.adapter.reportRenderFailure(this.props.surface.id, error.name);
+  }
+  render() {
+    if (this.state.failedSurfaceId !== void 0) {
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          "data-a2ui-error-boundary": "true",
+          tabIndex: -1,
+          ref: (node) => node?.focus(),
+          children: this.props.fallback
+        }
+      );
+    }
+    return this.props.children;
+  }
+};
+function annotateFields(root, fields, invalidFields, validationSummaryId) {
+  const originalAttributes = /* @__PURE__ */ new Map();
+  const matchCleanups = [];
+  for (const field of fields) {
+    const match = findFieldControls(root, field);
+    matchCleanups.push(match.cleanup);
+    for (const control of match.controls) {
+      if (!originalAttributes.has(control)) {
+        originalAttributes.set(control, {
+          field: control.dataset.a2uiField,
+          required: control.getAttribute("aria-required"),
+          invalid: control.getAttribute("aria-invalid"),
+          describedBy: control.getAttribute("aria-describedby")
+        });
+      }
+      control.dataset.a2uiField = field.field;
+      if (field.required) {
+        control.setAttribute("aria-required", "true");
+      }
+      if (invalidFields.has(field.field)) {
+        control.setAttribute("aria-invalid", "true");
+        if (validationSummaryId !== void 0) {
+          const describedBy = new Set(
+            (control.getAttribute("aria-describedby") ?? "").split(/\s+/).filter(Boolean)
+          );
+          describedBy.add(validationSummaryId);
+          control.setAttribute(
+            "aria-describedby",
+            [...describedBy].join(" ")
+          );
+        }
+      }
+    }
+  }
+  return () => {
+    for (const [control, original] of originalAttributes) {
+      if (original.field === void 0) {
+        delete control.dataset.a2uiField;
+      } else {
+        control.dataset.a2uiField = original.field;
+      }
+      restoreAttribute(control, "aria-required", original.required);
+      restoreAttribute(control, "aria-invalid", original.invalid);
+      restoreAttribute(control, "aria-describedby", original.describedBy);
+    }
+    for (const cleanup of matchCleanups.reverse()) {
+      cleanup();
+    }
+  };
+}
+function findFieldControls(root, field) {
+  const labels = [...root.querySelectorAll("label")];
+  const label = labels.find(
+    (candidate) => candidate.textContent?.trim() === field.label
+  );
+  if (label?.htmlFor) {
+    const control = root.ownerDocument.getElementById(label.htmlFor);
+    if (control instanceof HTMLElement && root.contains(control)) {
+      return { controls: [control], cleanup: () => void 0 };
+    }
+  }
+  const headings = [...root.querySelectorAll("strong")];
+  const heading = headings.find(
+    (candidate) => candidate.textContent?.trim() === field.label
+  );
+  if (heading === void 0) {
+    return { controls: [], cleanup: () => void 0 };
+  }
+  const group = heading.parentElement;
+  if (group === null) {
+    return { controls: [], cleanup: () => void 0 };
+  }
+  const originalHeadingId = heading.getAttribute("id");
+  const originalRole = group.getAttribute("role");
+  const originalLabelledBy = group.getAttribute("aria-labelledby");
+  const headingId = heading.id || `${safeDomToken(field.componentId)}-label`;
+  heading.id = headingId;
+  group.setAttribute("role", "radiogroup");
+  group.setAttribute("aria-labelledby", headingId);
+  return {
+    controls: [
+      ...group.querySelectorAll(
+        'input[type="radio"], input[type="checkbox"], button'
+      )
+    ],
+    cleanup: () => {
+      restoreAttribute(heading, "id", originalHeadingId);
+      restoreAttribute(group, "role", originalRole);
+      restoreAttribute(group, "aria-labelledby", originalLabelledBy);
+    }
+  };
+}
+function formatFieldLabels(root) {
+  const originals = /* @__PURE__ */ new Map();
+  for (const control of root.querySelectorAll("[data-a2ui-field]")) {
+    const field = control.dataset.a2uiField;
+    if (field === void 0) {
+      continue;
+    }
+    const label = labelElementForControl(root, control);
+    if (label === void 0 || originals.has(label)) {
+      continue;
+    }
+    originals.set(label, label.textContent ?? "");
+    label.textContent = displayFieldLabel(field);
+  }
+  return () => {
+    for (const [label, text] of originals) {
+      label.textContent = text;
+    }
+  };
+}
+function labelElementForControl(root, control) {
+  if (control.id.length > 0) {
+    const label2 = root.querySelector(
+      `label[for="${cssString(control.id)}"]`
+    );
+    if (label2 !== null) {
+      return label2;
+    }
+  }
+  const group = control.closest('[role="radiogroup"]');
+  const labelledBy = group?.getAttribute("aria-labelledby");
+  if (labelledBy === null || labelledBy === void 0 || labelledBy === "") {
+    return void 0;
+  }
+  const label = root.ownerDocument.getElementById(labelledBy);
+  return label instanceof HTMLElement && root.contains(label) ? label : void 0;
+}
+function displayFieldLabel(field) {
+  const words = field.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean);
+  return words.map((word, index) => displayFieldLabelWord(word, index)).join(" ");
+}
+function displayFieldLabelWord(word, index) {
+  const lower = word.toLowerCase();
+  const acronyms = {
+    dob: "DOB",
+    id: "ID",
+    ssn: "SSN",
+    url: "URL",
+    us: "US",
+    zip: "ZIP"
+  };
+  if (lower in acronyms) {
+    return acronyms[lower];
+  }
+  if (index > 0 && ["a", "an", "and", "for", "in", "of", "on", "or", "the", "to", "with"].includes(lower)) {
+    return lower;
+  }
+  return lower.charAt(0).toUpperCase() + lower.slice(1);
+}
+function cssString(value) {
+  return globalThis.CSS?.escape?.(value) ?? value.replace(/["\\]/g, "\\$&");
+}
+function enhanceTabs(root, tabs, navigation, viewedSectionId, frameId, onPanelChange, onViewSection) {
+  if (tabs.length === 0 || navigation === null || tabs.length !== navigation.orderedSectionIds.length) {
+    return () => void 0;
+  }
+  const header = findTabHeader(root, tabs);
+  if (header === void 0) {
+    return () => void 0;
+  }
+  const buttons = [...header.children].filter(
+    (child) => child instanceof HTMLButtonElement
+  );
+  const panel = header.nextElementSibling;
+  if (buttons.length !== tabs.length || panel === null) {
+    return () => void 0;
+  }
+  const statuses = tabStatuses(navigation);
+  const sectionIds = navigation.orderedSectionIds;
+  const enabled = statuses.map((status, index) => status === "future" ? -1 : index).filter((index) => index >= 0);
+  const authoritative = statuses.findIndex((status) => status === "active");
+  const requested = viewedSectionId === null ? -1 : sectionIds.indexOf(viewedSectionId);
+  const selectedIndex = requested >= 0 && statuses[requested] !== "future" ? requested : authoritative >= 0 ? authoritative : enabled[0] ?? 0;
+  const listeners = [];
+  let synchronizingRenderer = false;
+  header.dataset.a2uiTabList = "true";
+  header.setAttribute("role", "tablist");
+  header.setAttribute("aria-label", "Intake sections");
+  panel.dataset.a2uiTabPanel = "true";
+  panel.setAttribute("role", "tabpanel");
+  panel.tabIndex = 0;
+  panel.id = `${safeDomToken(frameId)}-tabpanel`;
+  const activate = (index) => {
+    const selected = buttons[index];
+    if (selected === void 0 || statuses[index] === "future") {
+      return;
+    }
+    buttons.forEach((button, buttonIndex) => {
+      const isSelected = buttonIndex === index;
+      button.setAttribute("aria-selected", String(isSelected));
+      button.tabIndex = isSelected ? 0 : -1;
+    });
+    panel.setAttribute("aria-labelledby", selected.id);
+    onPanelChange();
+  };
+  buttons.forEach((button, index) => {
+    button.dataset.a2uiTab = statuses[index];
+    button.setAttribute("role", "tab");
+    button.id = `${safeDomToken(frameId)}-tab-${index}`;
+    button.setAttribute("aria-controls", panel.id);
+    if (statuses[index] === "future") {
+      button.disabled = true;
+      button.setAttribute("aria-disabled", "true");
+      button.tabIndex = -1;
+    }
+    const onClick = () => {
+      activate(index);
+      if (!synchronizingRenderer) {
+        onViewSection(sectionIds[index]);
+      }
+    };
+    const onKeyDown = (event) => {
+      const destination = tabKeyboardDestination(
+        event,
+        index,
+        enabled
+      );
+      if (destination === void 0) {
+        return;
+      }
+      event.preventDefault();
+      buttons[destination]?.focus();
+      buttons[destination]?.click();
+    };
+    button.addEventListener("click", onClick);
+    button.addEventListener("keydown", onKeyDown);
+    listeners.push(() => {
+      button.removeEventListener("click", onClick);
+      button.removeEventListener("keydown", onKeyDown);
+    });
+  });
+  synchronizingRenderer = true;
+  buttons[selectedIndex]?.click();
+  synchronizingRenderer = false;
+  activate(selectedIndex);
+  return () => {
+    for (const remove of listeners) {
+      remove();
+    }
+    delete header.dataset.a2uiTabList;
+    header.removeAttribute("role");
+    header.removeAttribute("aria-label");
+    delete panel.dataset.a2uiTabPanel;
+    panel.removeAttribute("role");
+    panel.removeAttribute("aria-labelledby");
+    panel.removeAttribute("id");
+    panel.removeAttribute("tabindex");
+    buttons.forEach((button) => {
+      delete button.dataset.a2uiTab;
+      button.removeAttribute("role");
+      button.removeAttribute("aria-selected");
+      button.removeAttribute("aria-controls");
+      button.removeAttribute("aria-disabled");
+      button.removeAttribute("id");
+      button.removeAttribute("tabindex");
+      button.disabled = false;
+    });
+  };
+}
+function findTabHeader(root, tabs) {
+  return [...root.querySelectorAll("div")].find((candidate) => {
+    const directButtons = [...candidate.children].filter(
+      (child) => child instanceof HTMLButtonElement
+    );
+    return directButtons.length === tabs.length && directButtons.every(
+      (button, index) => button.textContent?.trim() === tabs[index]?.title
+    );
+  });
+}
+function tabStatuses(navigation) {
+  const completed = new Set(navigation.completedSectionIds);
+  const future = new Set(navigation.futureSectionIds);
+  return navigation.orderedSectionIds.map((sectionId) => {
+    if (sectionId === navigation.activeSectionId) {
+      return "active";
+    }
+    return completed.has(sectionId) ? "completed" : future.has(sectionId) ? "future" : "future";
+  });
+}
+function tabKeyboardDestination(event, current, enabled) {
+  const currentEnabledIndex = enabled.indexOf(current);
+  if (event.key === "Home") {
+    return enabled[0];
+  }
+  if (event.key === "End") {
+    return enabled.at(-1);
+  }
+  if (event.key !== "ArrowRight" && event.key !== "ArrowLeft") {
+    return void 0;
+  }
+  const delta = event.key === "ArrowRight" ? 1 : -1;
+  const start = currentEnabledIndex >= 0 ? currentEnabledIndex : 0;
+  return enabled[(start + delta + enabled.length) % enabled.length];
+}
+function setPendingGroupsDisabled(root, pendingGroupIds) {
+  if (pendingGroupIds.size === 0) {
+    return () => void 0;
+  }
+  const originals = /* @__PURE__ */ new Map();
+  for (const control of root.querySelectorAll(
+    "[data-a2ui-group-id]"
+  )) {
+    if (!isDisableableControl(control) || !pendingGroupIds.has(control.dataset.a2uiGroupId ?? "")) {
+      continue;
+    }
+    originals.set(control, {
+      disabled: control.disabled,
+      busy: control.getAttribute("aria-busy"),
+      pending: control.dataset.a2uiGroupPending
+    });
+    control.disabled = true;
+    control.setAttribute("aria-busy", "true");
+    control.dataset.a2uiGroupPending = "true";
+  }
+  return () => {
+    for (const [control, original] of originals) {
+      control.disabled = original.disabled;
+      restoreAttribute(control, "aria-busy", original.busy);
+      restoreDataset(
+        control,
+        "a2uiGroupPending",
+        original.pending
+      );
+    }
+  };
+}
+function isDisableableControl(control) {
+  return control instanceof HTMLButtonElement || control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement || control instanceof HTMLSelectElement;
+}
+function setInteractionDisabled(root, disabled) {
+  if (!disabled) {
+    root.removeAttribute("inert");
+    return () => void 0;
+  }
+  root.setAttribute("inert", "");
+  const controls = [
+    ...root.querySelectorAll("button, input, textarea, select")
+  ];
+  for (const control of controls) {
+    if (!control.disabled) {
+      control.disabled = true;
+      control.dataset.a2uiSessionDisabled = "true";
+    }
+  }
+  return () => {
+    root.removeAttribute("inert");
+    for (const control of controls) {
+      if (control.dataset.a2uiSessionDisabled === "true") {
+        control.disabled = false;
+        delete control.dataset.a2uiSessionDisabled;
+      }
+    }
+  };
+}
+function safeDomToken(value) {
+  return value.replace(/[^A-Za-z0-9_-]/g, "-");
+}
+function restoreAttribute(element, name, value) {
+  if (value === null) {
+    element.removeAttribute(name);
+  } else {
+    element.setAttribute(name, value);
+  }
+}
+
+// src/session.ts
+import { A2uiMessageListSchema as A2uiMessageListSchema2 } from "@a2ui/web_core/v0_9";
+
+// src/actions.ts
+var DEFAULT_ACK_TIMEOUT_MS = 1e4;
+var SAFE_DETAIL = /^[A-Za-z0-9_.:-]{1,96}$/;
+var MAX_IDENTIFIER_LENGTH = 256;
+var EMPTY_ACTION_STATE = {
+  pendingRequests: [],
+  lastResult: null
+};
+var A2UIClientActionBridge = class {
+  #options;
+  #pendingByKey = /* @__PURE__ */ new Map();
+  #pendingByRequestId = /* @__PURE__ */ new Map();
+  #lastResult = null;
+  #publishQueue = Promise.resolve();
+  #closed = false;
+  constructor(options) {
+    this.#options = options;
+  }
+  getSnapshot() {
+    if (this.#pendingByKey.size === 0 && this.#lastResult === null) {
+      return EMPTY_ACTION_STATE;
+    }
+    return {
+      pendingRequests: [...this.#pendingByKey.values()].map((pending) => ({
+        requestId: pending.requestId,
+        action: pending.action,
+        surfaceId: pending.surfaceId,
+        stateId: pending.stateId,
+        revision: pending.revision,
+        deliveryStatus: pending.deliveryStatus,
+        attemptCount: pending.attemptCount,
+        ...pending.groupId === void 0 ? {} : { groupId: pending.groupId }
+      })),
+      lastResult: this.#lastResult === null ? null : {
+        ...this.#lastResult,
+        fieldErrors: this.#lastResult.fieldErrors.map((entry) => ({
+          ...entry
+        })),
+        ...this.#lastResult.groupId === void 0 ? {} : { groupId: this.#lastResult.groupId }
+      }
+    };
+  }
+  handleRendererAction(event) {
+    if (this.#closed || !this.#options.canPublish()) {
+      return;
+    }
+    const metadata = this.#options.getSurfaceMetadata();
+    if (metadata === null || metadata.activeStateId === null || event.surfaceId !== metadata.surfaceId) {
+      this.#rejectRendererAction(event.surfaceId, "action_metadata_stale");
+      return;
+    }
+    const decoded = decodeRendererAction(event);
+    if (decoded === null) {
+      this.#rejectRendererAction(event.surfaceId, "action_context_invalid");
+      return;
+    }
+    const key = pendingKey(metadata.surfaceId, metadata.activeStateId);
+    const existing = this.#pendingByKey.get(key);
+    if (existing !== void 0) {
+      if (existing.deliveryStatus === "retryable" && isSameLogicalAction(existing.envelope, decoded)) {
+        this.#queueAttempt(existing);
+      }
+      return;
+    }
+    this.#startLogicalAction(decoded, key);
+  }
+  /** Publish one strict server-issued owning-group commit. */
+  handleFieldGroupCommit(group, fields) {
+    if (this.#closed || !this.#options.canPublish()) {
+      return false;
+    }
+    const metadata = this.#options.getSurfaceMetadata();
+    if (metadata === null || metadata.activeStateId === null) {
+      return false;
+    }
+    const expected = group.fields.map((binding) => binding.field);
+    if (expected.length === 0 || Object.keys(fields).length !== expected.length || expected.some((field) => !Object.hasOwn(fields, field)) || group.mode === "current" && group.ownerStateId !== metadata.activeStateId || group.mode === "revision" && group.ownerStateId === metadata.activeStateId) {
+      return false;
+    }
+    const orderedFields = {};
+    for (const field of expected) {
+      const value = normalizeFieldValue(fields[field]);
+      if (value === void 0) {
+        return false;
+      }
+      orderedFields[field] = value;
+    }
+    const key = groupPendingKey(metadata.surfaceId, group.groupId);
+    if (this.#pendingByKey.has(key)) {
+      return false;
+    }
+    const decoded = group.mode === "current" ? { action: "flow.submit", payload: { fields: orderedFields } } : {
+      action: "flow.revise",
+      payload: {
+        targetStateId: group.ownerStateId,
+        fields: orderedFields
+      }
+    };
+    return this.#startLogicalAction(decoded, key, group.groupId);
+  }
+  #startLogicalAction(decoded, key, groupId) {
+    const metadata = this.#options.getSurfaceMetadata();
+    if (metadata === null || metadata.activeStateId === null) {
+      return false;
+    }
+    let requestId;
+    try {
+      requestId = createRequestId("req");
+    } catch {
+      return false;
+    }
+    const envelope = {
+      envelopeVersion: ENVELOPE_VERSION,
+      a2uiVersion: A2UI_PROTOCOL_VERSION,
+      kind: "action",
+      requestId,
+      role: this.#options.participantRole ?? "member",
+      surfaceId: metadata.surfaceId,
+      stateId: metadata.activeStateId,
+      revision: metadata.revision,
+      action: decoded.action,
+      ...decoded.payload === void 0 ? {} : { payload: decoded.payload }
+    };
+    const encoded = encodeEnvelope(envelope);
+    if (encoded === null) {
+      this.#options.reportClientError(
+        "message_malformed",
+        envelope.surfaceId,
+        "action_envelope_too_large"
+      );
+      return false;
+    }
+    const pending = {
+      requestId,
+      action: envelope.action,
+      surfaceId: envelope.surfaceId,
+      stateId: envelope.stateId,
+      revision: envelope.revision,
+      deliveryStatus: "publishing",
+      attemptCount: 0,
+      generation: 0,
+      envelope,
+      encoded,
+      key,
+      ...groupId === void 0 ? {} : { groupId }
+    };
+    this.#pendingByKey.set(key, pending);
+    this.#pendingByRequestId.set(requestId, pending);
+    this.#queueAttempt(pending);
+    return true;
+  }
+  handleClientError(event) {
+    if (this.#closed || !this.#options.canPublish()) {
+      return;
+    }
+    let requestId;
+    try {
+      requestId = createRequestId("err");
+    } catch {
+      return;
+    }
+    const surfaceId = safeIdentifier(event.surfaceId);
+    const detail = safeDetail(event.detail);
+    const envelope = {
+      envelopeVersion: ENVELOPE_VERSION,
+      a2uiVersion: A2UI_PROTOCOL_VERSION,
+      kind: "clientError",
+      requestId,
+      role: this.#options.participantRole ?? "member",
+      errorCode: event.errorCode,
+      ...surfaceId === void 0 ? {} : { surfaceId },
+      ...detail === void 0 ? {} : { detail }
+    };
+    const encoded = encodeEnvelope(envelope);
+    if (encoded !== null) {
+      this.#enqueue(async () => {
+        await this.#options.publish(encoded);
+      });
+    }
+  }
+  handleAck(envelope) {
+    if (this.#closed) {
+      return false;
+    }
+    const pending = this.#pendingByRequestId.get(envelope.inResponseTo);
+    if (pending === void 0) {
+      return false;
+    }
+    this.#removePending(pending);
+    this.#lastResult = {
+      requestId: pending.requestId,
+      action: pending.action,
+      surfaceId: pending.surfaceId,
+      stateId: pending.stateId,
+      revision: pending.revision,
+      status: envelope.status,
+      ...envelope.reasonCode === void 0 ? {} : { reasonCode: envelope.reasonCode },
+      fieldErrors: (envelope.fieldErrors ?? []).map((entry) => ({ ...entry })),
+      ...pending.groupId === void 0 ? {} : { groupId: pending.groupId }
+    };
+    this.#notify();
+    return true;
+  }
+  markReconnect() {
+    if (this.#closed) {
+      return;
+    }
+    let changed = false;
+    for (const pending of this.#pendingByKey.values()) {
+      this.#clearTimer(pending);
+      pending.generation += 1;
+      if (pending.deliveryStatus !== "retryable") {
+        pending.deliveryStatus = "retryable";
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.#notify();
+    }
+  }
+  retryAfterRestore() {
+    if (this.#closed || !this.#options.canPublish()) {
+      return;
+    }
+    for (const pending of this.#pendingByKey.values()) {
+      if (pending.deliveryStatus === "retryable") {
+        this.#queueAttempt(pending);
+      }
+    }
+  }
+  retryPendingAction(requestId) {
+    if (this.#closed || !this.#options.canPublish()) {
+      return false;
+    }
+    const candidates = requestId === void 0 ? [...this.#pendingByKey.values()] : [this.#pendingByRequestId.get(requestId)].filter(
+      (entry) => entry !== void 0
+    );
+    let retried = false;
+    for (const pending of candidates) {
+      if (pending.deliveryStatus === "retryable") {
+        this.#queueAttempt(pending);
+        retried = true;
+      }
+    }
+    return retried;
+  }
+  discardPending() {
+    if (this.#pendingByKey.size === 0) {
+      return;
+    }
+    for (const pending of this.#pendingByKey.values()) {
+      this.#clearTimer(pending);
+      pending.generation += 1;
+    }
+    this.#pendingByKey.clear();
+    this.#pendingByRequestId.clear();
+    this.#notify();
+  }
+  stop() {
+    if (this.#closed) {
+      return;
+    }
+    this.#closed = true;
+    this.discardPending();
+    this.#lastResult = null;
+  }
+  #rejectRendererAction(surfaceId, detail) {
+    this.#options.reportClientError(
+      "message_malformed",
+      safeIdentifier(surfaceId),
+      detail
+    );
+  }
+  #queueAttempt(pending) {
+    if (this.#closed || !this.#options.canPublish()) {
+      return;
+    }
+    this.#clearTimer(pending);
+    pending.deliveryStatus = "publishing";
+    pending.attemptCount += 1;
+    pending.generation += 1;
+    const generation = pending.generation;
+    this.#notify();
+    this.#enqueue(async () => {
+      if (!this.#isCurrent(pending, generation)) {
+        return;
+      }
+      try {
+        await this.#options.publish(pending.encoded);
+      } catch {
+        if (this.#isCurrent(pending, generation)) {
+          pending.deliveryStatus = "retryable";
+          this.#notify();
+        }
+        return;
+      }
+      if (!this.#isCurrent(pending, generation)) {
+        return;
+      }
+      pending.deliveryStatus = "awaiting_ack";
+      pending.timeoutId = globalThis.setTimeout(() => {
+        if (this.#isCurrent(pending, generation)) {
+          pending.timeoutId = void 0;
+          pending.deliveryStatus = "retryable";
+          this.#notify();
+        }
+      }, this.#ackTimeoutMs());
+      this.#notify();
+    });
+  }
+  #enqueue(operation) {
+    this.#publishQueue = this.#publishQueue.then(operation).catch(() => void 0);
+  }
+  #ackTimeoutMs() {
+    const configured = this.#options.ackTimeoutMs;
+    return typeof configured === "number" && Number.isFinite(configured) && configured > 0 ? configured : DEFAULT_ACK_TIMEOUT_MS;
+  }
+  #isCurrent(pending, generation) {
+    return !this.#closed && pending.generation === generation && this.#pendingByRequestId.get(pending.requestId) === pending;
+  }
+  #removePending(pending) {
+    this.#clearTimer(pending);
+    pending.generation += 1;
+    this.#pendingByKey.delete(pending.key);
+    this.#pendingByRequestId.delete(pending.requestId);
+  }
+  #clearTimer(pending) {
+    if (pending.timeoutId !== void 0) {
+      globalThis.clearTimeout(pending.timeoutId);
+      pending.timeoutId = void 0;
+    }
+  }
+  #notify() {
+    this.#options.onStateChange(this.getSnapshot());
+  }
+};
+function decodeRendererAction(event) {
+  if (!CLIENT_ACTIONS.includes(event.actionName)) {
+    return null;
+  }
+  const action = event.actionName;
+  const entries = Object.entries(event.context).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  if (entries.some(([key]) => key.length === 0)) {
+    return null;
+  }
+  if (action === "flow.skip") {
+    return entries.length === 0 ? { action } : null;
+  }
+  if (action === "flow.submit") {
+    const fields2 = scalarFields(entries);
+    return fields2 === null || Object.keys(fields2).length === 0 ? null : { action, payload: { fields: fields2 } };
+  }
+  if (action === "flow.list.add" || action === "flow.list.update" || action === "flow.list.delete") {
+    const listPath = event.context.listPath;
+    if (typeof listPath !== "string" || listPath.length === 0) {
+      return null;
+    }
+    const itemId = event.context.itemId;
+    if ((action === "flow.list.update" || action === "flow.list.delete") && (typeof itemId !== "string" || itemId.length === 0)) {
+      return null;
+    }
+    const fieldEntries2 = entries.filter(
+      ([key]) => key !== "listPath" && key !== "itemId"
+    );
+    const fields2 = scalarFields(fieldEntries2);
+    if (action !== "flow.list.delete" && (fields2 === null || Object.keys(fields2).length === 0)) {
+      return null;
+    }
+    return {
+      action,
+      payload: {
+        listPath,
+        ...typeof itemId === "string" ? { itemId } : {},
+        ...fields2 !== null && Object.keys(fields2).length > 0 ? { fields: fields2 } : {}
+      }
+    };
+  }
+  const targetStateId = event.context.targetStateId;
+  if (typeof targetStateId !== "string" || targetStateId.length === 0) {
+    return null;
+  }
+  const fieldEntries = entries.filter(([key]) => key !== "targetStateId");
+  const fields = scalarFields(fieldEntries);
+  if (fields === null) {
+    return null;
+  }
+  return {
+    action,
+    payload: {
+      targetStateId,
+      ...Object.keys(fields).length === 0 ? {} : { fields }
+    }
+  };
+}
+function scalarFields(entries) {
+  const fields = {};
+  for (const [key, value] of entries) {
+    const normalized = normalizeFieldValue(value);
+    if (normalized === void 0) {
+      return null;
+    }
+    fields[key] = normalized;
+  }
+  return fields;
+}
+function isSameLogicalAction(envelope, candidate) {
+  return envelope.action === candidate.action && JSON.stringify(envelope.payload) === JSON.stringify(candidate.payload);
+}
+function pendingKey(surfaceId, stateId) {
+  return JSON.stringify([surfaceId, stateId]);
+}
+function groupPendingKey(surfaceId, groupId) {
+  return JSON.stringify(["group", surfaceId, groupId]);
+}
+function isFieldValue2(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function normalizeFieldValue(value) {
+  if (isFieldValue2(value)) {
+    return value;
+  }
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  if (value.length === 0) {
+    return null;
+  }
+  if (value.length !== 1) {
+    return void 0;
+  }
+  return normalizeFieldValue(value[0]);
+}
+function encodeEnvelope(envelope) {
+  let encoded;
+  try {
+    encoded = JSON.stringify(envelope);
+  } catch {
+    return null;
+  }
+  return new TextEncoder().encode(encoded).byteLength <= MAX_ENVELOPE_BYTES ? encoded : null;
+}
+function createRequestId(prefix) {
+  return `${prefix}-${globalThis.crypto.randomUUID()}`;
+}
+function safeIdentifier(value) {
+  return value !== void 0 && value.length > 0 && value.length <= MAX_IDENTIFIER_LENGTH ? value : void 0;
+}
+function safeDetail(value) {
+  return value !== void 0 && SAFE_DETAIL.test(value) ? value : void 0;
+}
+
+// src/session.ts
+var DEFAULT_CAPABILITY_RETRY_SCHEDULE_MS = [250, 1e3, 2500, 5e3];
+var A2UISessionController = class {
+  #room;
+  #adapter;
+  #isTrustedServerParticipant;
+  #participantRole;
+  #capabilityRetryScheduleMs;
+  #actionBridge;
+  #listeners = /* @__PURE__ */ new Set();
+  #sessionSnapshot = {
+    status: "idle",
+    restoring: false,
+    surface: null,
+    actions: { pendingRequests: [], lastResult: null },
+    editing: emptyEditingSnapshot()
+  };
+  #startPromise;
+  #deliveryQueue = Promise.resolve();
+  #handlerRegistered = false;
+  #listenersRegistered = false;
+  #closed = false;
+  #pendingSnapshotRequestId;
+  #capabilityGeneration = 0;
+  #restoreResetsSequence = false;
+  #revisionBaseline;
+  #unsubscribeActions;
+  #unsubscribeClientErrors;
+  #capabilityRetryTimers = [];
+  #draftsByGroup = /* @__PURE__ */ new Map();
+  #authoritativeByGroup = /* @__PURE__ */ new Map();
+  #rejectedGroupIds = /* @__PURE__ */ new Set();
+  #handledActionResultRequestId;
+  constructor(options) {
+    this.#room = options.room;
+    this.#adapter = options.adapter;
+    this.#isTrustedServerParticipant = options.isTrustedServerParticipant;
+    this.#participantRole = options.participantRole ?? "member";
+    this.#capabilityRetryScheduleMs = options.capabilityRetryScheduleMs ?? DEFAULT_CAPABILITY_RETRY_SCHEDULE_MS;
+    this.#actionBridge = new A2UIClientActionBridge({
+      publish: async (text) => this.#room.localParticipant.sendText(text, {
+        topic: A2UI_CLIENT_TOPIC
+      }),
+      canPublish: () => !this.#closed && this.status === "connected" && !this.restoring,
+      getSurfaceMetadata: () => this.surfaceMetadata,
+      reportClientError: (errorCode, surfaceId, detail) => this.#adapter.reportClientError(errorCode, surfaceId, detail),
+      onStateChange: (actions) => this.#handleActionStateChange(actions),
+      participantRole: this.#participantRole,
+      ackTimeoutMs: options.actionAckTimeoutMs
+    });
+  }
+  get status() {
+    return this.#sessionSnapshot.status;
+  }
+  get restoring() {
+    return this.#sessionSnapshot.restoring;
+  }
+  get surfaceMetadata() {
+    return this.#sessionSnapshot.surface;
+  }
+  get actionState() {
+    return this.#sessionSnapshot.actions;
+  }
+  /** Retry one or every delivery-failed/timed-out request with its original id. */
+  retryPendingAction(requestId) {
+    return this.#actionBridge.retryPendingAction(requestId);
+  }
+  /** Select the authoritative server-owned section without choosing workflow state. */
+  returnToCurrentSection() {
+    const authoritative = this.#sessionSnapshot.editing.authoritativeSectionId;
+    if (authoritative === null) {
+      return false;
+    }
+    return this.viewSection(authoritative);
+  }
+  /** View one exact server-issued active/completed section locally. */
+  viewSection(sectionId) {
+    const navigation = this.surfaceMetadata?.sectionNavigation;
+    if (navigation === null || navigation === void 0 || sectionId === this.#sessionSnapshot.editing.viewedSectionId || sectionId !== navigation.activeSectionId && !navigation.completedSectionIds.includes(sectionId)) {
+      return false;
+    }
+    this.#replaceSnapshot({
+      editing: {
+        ...this.#sessionSnapshot.editing,
+        viewedSectionId: sectionId
+      }
+    });
+    return true;
+  }
+  /** Capture a renderer-owned group after a real user input/change event. */
+  captureFieldGroupDraft(groupId) {
+    const surface = this.surfaceMetadata;
+    const group = surface?.fieldInteractions.find(
+      (candidate) => candidate.groupId === groupId
+    );
+    if (surface === null || group === void 0 || this.#pendingGroupIds(this.actionState).has(groupId)) {
+      return false;
+    }
+    const fields = group.fields.map((binding) => binding.field);
+    const values = this.#adapter.getFieldValues(surface.surfaceId, fields);
+    const authoritative = this.#authoritativeByGroup.get(groupId);
+    if (values === null || authoritative === void 0) {
+      return false;
+    }
+    if (fieldValuesEqual(values, authoritative, fields)) {
+      this.#draftsByGroup.delete(groupId);
+      this.#rejectedGroupIds.delete(groupId);
+    } else {
+      this.#draftsByGroup.set(groupId, {
+        surfaceId: surface.surfaceId,
+        fields,
+        baseValues: { ...authoritative },
+        values: { ...values }
+      });
+      this.#rejectedGroupIds.delete(groupId);
+    }
+    this.#replaceSnapshot({ editing: this.#editingSnapshot() });
+    return true;
+  }
+  /** Commit one complete owning group against the latest surface revision. */
+  commitFieldGroup(groupId) {
+    if (this.status !== "connected" || this.restoring) {
+      return false;
+    }
+    this.captureFieldGroupDraft(groupId);
+    const surface = this.surfaceMetadata;
+    const group = surface?.fieldInteractions.find(
+      (candidate) => candidate.groupId === groupId
+    );
+    const draft = this.#draftsByGroup.get(groupId);
+    const authoritative = this.#authoritativeByGroup.get(groupId);
+    if (surface === null || group === void 0 || draft === void 0 || authoritative === void 0 || this.#pendingGroupIds(this.actionState).has(groupId) || fieldValuesEqual(draft.values, authoritative, draft.fields) || !this.#groupIsComplete(surface, group, draft.values)) {
+      return false;
+    }
+    return this.#actionBridge.handleFieldGroupCommit(group, draft.values);
+  }
+  getSnapshot = () => this.#sessionSnapshot;
+  subscribe = (listener) => {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  };
+  /** Register the server stream before announcing exact renderer capability. */
+  async start() {
+    if (this.#closed || this.status === "closed") {
+      return;
+    }
+    if (this.#startPromise === void 0) {
+      this.#startPromise = this.#startInternal();
+    }
+    await this.#startPromise;
+  }
+  /**
+   * Detach only A2UI handlers/listeners. The shared room remains caller-owned.
+   */
+  stop() {
+    if (this.#closed) {
+      return;
+    }
+    this.#closed = true;
+    this.#capabilityGeneration += 1;
+    this.#pendingSnapshotRequestId = void 0;
+    this.#clearCapabilityRetryTimers();
+    this.#restoreResetsSequence = false;
+    this.#actionBridge.stop();
+    this.#detach();
+    this.#adapter.clearSurfaces();
+    this.#revisionBaseline = void 0;
+    this.#clearDrafts();
+    this.#replaceSnapshot({
+      status: "closed",
+      restoring: false,
+      surface: null,
+      actions: { pendingRequests: [], lastResult: null },
+      editing: emptyEditingSnapshot()
+    });
+    this.#listeners.clear();
+  }
+  async #startInternal() {
+    this.#replaceSnapshot({ status: "connecting" });
+    try {
+      this.#unsubscribeActions = this.#adapter.subscribeActions(
+        this.#handleRendererAction
+      );
+      this.#unsubscribeClientErrors = this.#adapter.subscribeClientErrors(
+        this.#handleClientError
+      );
+      this.#room.registerTextStreamHandler(
+        A2UI_SERVER_TOPIC,
+        this.#handleTextStream
+      );
+      this.#handlerRegistered = true;
+      this.#listenersRegistered = true;
+      this.#room.on("reconnected", this.#handleReconnected);
+      this.#room.on("disconnected", this.#handleDisconnected);
+    } catch {
+      this.#closeAfterStartupFailure();
+      return;
+    }
+    const requestId = await this.#announceCapabilities();
+    if (requestId === void 0) {
+      this.#closeAfterStartupFailure();
+      return;
+    }
+    if (!this.#closed) {
+      this.#replaceSnapshot({ status: "connected" });
+    }
+  }
+  #closeAfterStartupFailure() {
+    this.#closed = true;
+    this.#pendingSnapshotRequestId = void 0;
+    this.#clearCapabilityRetryTimers();
+    this.#actionBridge.stop();
+    this.#detach();
+    this.#adapter.clearSurfaces();
+    this.#revisionBaseline = void 0;
+    this.#clearDrafts();
+    this.#replaceSnapshot({
+      status: "closed",
+      restoring: false,
+      surface: null,
+      actions: { pendingRequests: [], lastResult: null },
+      editing: emptyEditingSnapshot()
+    });
+  }
+  #detach() {
+    this.#clearCapabilityRetryTimers();
+    this.#unsubscribeActions?.();
+    this.#unsubscribeActions = void 0;
+    this.#unsubscribeClientErrors?.();
+    this.#unsubscribeClientErrors = void 0;
+    if (this.#handlerRegistered) {
+      try {
+        this.#room.unregisterTextStreamHandler(A2UI_SERVER_TOPIC);
+      } catch {
+      }
+      this.#handlerRegistered = false;
+    }
+    if (this.#listenersRegistered) {
+      try {
+        this.#room.off("reconnected", this.#handleReconnected);
+      } catch {
+      }
+      try {
+        this.#room.off("disconnected", this.#handleDisconnected);
+      } catch {
+      }
+      this.#listenersRegistered = false;
+    }
+  }
+  #handleTextStream = (reader, participant) => {
+    if (this.#closed || !this.#handlerRegistered) {
+      return;
+    }
+    let trusted = false;
+    try {
+      trusted = isNonEmptyString2(participant?.identity) && this.#isTrustedServerParticipant(participant);
+    } catch {
+      trusted = false;
+    }
+    if (!trusted) {
+      return;
+    }
+    this.#deliveryQueue = this.#deliveryQueue.then(async () => this.#readAndProcess(reader)).catch(() => {
+      this.#reportInboundError("message_malformed", "delivery_failed");
+    });
+  };
+  #handleRendererAction = (event) => {
+    this.#actionBridge.handleRendererAction(event);
+  };
+  #handleClientError = (event) => {
+    this.#actionBridge.handleClientError(event);
+  };
+  async #readAndProcess(reader) {
+    if (this.#closed) {
+      return;
+    }
+    if (typeof reader.info?.size === "number" && reader.info.size > MAX_ENVELOPE_BYTES) {
+      this.#reportInboundError("message_malformed", "envelope_too_large");
+      return;
+    }
+    let text;
+    try {
+      text = await reader.readAll();
+    } catch {
+      this.#reportInboundError("message_malformed", "stream_read_failed");
+      return;
+    }
+    if (this.#closed || typeof text !== "string") {
+      return;
+    }
+    if (new TextEncoder().encode(text).byteLength > MAX_ENVELOPE_BYTES) {
+      this.#reportInboundError("message_malformed", "envelope_too_large");
+      return;
+    }
+    const decoded = decodeServerEnvelope(text);
+    if (!decoded.ok) {
+      this.#reportInboundError(decoded.errorCode, decoded.detail);
+      return;
+    }
+    await this.#processEnvelope(decoded.envelope);
+  }
+  async #processEnvelope(envelope) {
+    if (this.#closed) {
+      return;
+    }
+    const correlated = this.#pendingSnapshotRequestId !== void 0 && "inResponseTo" in envelope && envelope.inResponseTo === this.#pendingSnapshotRequestId;
+    if (correlated && envelope.kind === "snapshot") {
+      await this.#applyAuthoritativeSnapshot(envelope);
+      return;
+    }
+    if (correlated && envelope.kind === "ack") {
+      if (await this.#handleCapabilityAck(envelope)) {
+        return;
+      }
+    }
+    if (this.status === "unsupported") {
+      return;
+    }
+    if (this.restoring && envelope.kind !== "ack") {
+      if (this.#pendingSnapshotRequestId === void 0) {
+        await this.#announceCapabilities();
+      }
+      return;
+    }
+    if (envelope.seq <= this.#adapter.lastSeq) {
+      return;
+    }
+    if (envelope.kind === "ack") {
+      if (this.#adapter.applyServerEnvelope(envelope) && !this.restoring) {
+        this.#actionBridge.handleAck(envelope);
+      }
+      return;
+    }
+    if (envelope.kind === "snapshot") {
+      await this.#applyAuthoritativeSnapshot(envelope);
+      return;
+    }
+    await this.#applyContiguousUpdate(envelope);
+  }
+  async #applyContiguousUpdate(envelope) {
+    const baseline = this.#revisionBaseline;
+    if (baseline !== void 0) {
+      if (baseline.surfaceId !== envelope.surfaceId) {
+        await this.#enterRestoreBarrier();
+        return;
+      }
+      if (envelope.revision <= baseline.revision) {
+        return;
+      }
+      if (envelope.revision !== baseline.revision + 1) {
+        await this.#enterRestoreBarrier();
+        return;
+      }
+    }
+    if (!this.#adapter.applyServerEnvelope(envelope)) {
+      await this.#enterRestoreBarrier();
+      return;
+    }
+    this.#revisionBaseline = {
+      surfaceId: envelope.surfaceId,
+      revision: envelope.revision
+    };
+    const surface = this.#metadataAfterApply(envelope);
+    this.#reconcileDrafts(envelope, surface);
+    this.#replaceSnapshot({
+      surface,
+      editing: this.#editingSnapshot(surface)
+    });
+  }
+  async #applyAuthoritativeSnapshot(envelope) {
+    const correlated = this.#pendingSnapshotRequestId !== void 0 && envelope.inResponseTo === this.#pendingSnapshotRequestId;
+    if (this.restoring && !correlated) {
+      return;
+    }
+    if (correlated && this.#restoreResetsSequence) {
+      this.#adapter.resetSequence();
+      this.#restoreResetsSequence = false;
+    } else if (envelope.seq <= this.#adapter.lastSeq) {
+      return;
+    }
+    if (!this.#adapter.applyServerEnvelope(envelope)) {
+      if (correlated) {
+        this.#pendingSnapshotRequestId = void 0;
+      }
+      await this.#enterRestoreBarrier();
+      return;
+    }
+    this.#revisionBaseline = {
+      surfaceId: envelope.surfaceId,
+      revision: envelope.revision
+    };
+    this.#clearCapabilityRetryTimers();
+    if (correlated) {
+      this.#pendingSnapshotRequestId = void 0;
+    }
+    const surface = this.#metadataAfterApply(envelope);
+    this.#reconcileDrafts(envelope, surface);
+    this.#replaceSnapshot({
+      status: "connected",
+      restoring: false,
+      surface,
+      editing: this.#editingSnapshot(surface)
+    });
+    this.#actionBridge.retryAfterRestore();
+  }
+  async #handleCapabilityAck(envelope) {
+    if (envelope.status === "rejected" && (envelope.reasonCode === "a2ui_version_unsupported" || envelope.reasonCode === "catalog_unsupported")) {
+      if (this.#restoreResetsSequence) {
+        this.#adapter.resetSequence();
+        this.#restoreResetsSequence = false;
+      }
+      this.#adapter.applyServerEnvelope(envelope);
+      this.#adapter.clearSurfaces();
+      this.#actionBridge.discardPending();
+      this.#pendingSnapshotRequestId = void 0;
+      this.#clearCapabilityRetryTimers();
+      this.#revisionBaseline = void 0;
+      this.#clearDrafts();
+      this.#replaceSnapshot({
+        status: "unsupported",
+        restoring: false,
+        surface: null
+      });
+      return true;
+    }
+    if (envelope.status === "accepted" && envelope.noSurface === true) {
+      if (this.#restoreResetsSequence) {
+        this.#adapter.resetSequence();
+        this.#restoreResetsSequence = false;
+      }
+      this.#adapter.applyServerEnvelope(envelope);
+      this.#adapter.clearSurfaces();
+      this.#pendingSnapshotRequestId = void 0;
+      this.#clearCapabilityRetryTimers();
+      this.#revisionBaseline = void 0;
+      this.#clearDrafts();
+      this.#replaceSnapshot({
+        status: "connected",
+        restoring: false,
+        surface: null
+      });
+      this.#actionBridge.retryAfterRestore();
+      return true;
+    }
+    return false;
+  }
+  async #enterRestoreBarrier() {
+    if (this.#closed) {
+      return;
+    }
+    if (!this.restoring) {
+      this.#actionBridge.markReconnect();
+      this.#replaceSnapshot({ restoring: true });
+    }
+    if (this.#pendingSnapshotRequestId === void 0) {
+      await this.#announceCapabilities();
+    }
+  }
+  #metadataAfterApply(envelope) {
+    if (this.#adapter.getSurface(envelope.surfaceId) === void 0) {
+      return null;
+    }
+    return {
+      surfaceId: envelope.surfaceId,
+      activeStateId: envelope.activeStateId ?? null,
+      revision: envelope.revision,
+      sectionNavigation: cloneSectionNavigation(
+        envelope.sectionNavigation ?? null
+      ),
+      fieldInteractions: cloneFieldInteractions(
+        envelope.fieldInteractions ?? []
+      )
+    };
+  }
+  #handleActionStateChange(actions) {
+    const result = actions.lastResult;
+    let acceptedGroup = false;
+    let rejectedGroupId;
+    if (result?.groupId !== void 0 && result.requestId !== this.#handledActionResultRequestId) {
+      this.#handledActionResultRequestId = result.requestId;
+      if (result.status === "accepted") {
+        acceptedGroup = true;
+        const acceptedDraft = this.#draftsByGroup.get(result.groupId);
+        if (acceptedDraft !== void 0) {
+          this.#authoritativeByGroup.set(result.groupId, {
+            ...acceptedDraft.values
+          });
+        }
+        this.#draftsByGroup.delete(result.groupId);
+        this.#rejectedGroupIds.delete(result.groupId);
+      } else if (this.#draftsByGroup.has(result.groupId)) {
+        this.#rejectedGroupIds.add(result.groupId);
+        rejectedGroupId = result.groupId;
+      }
+    }
+    let editing = this.#editingSnapshot(void 0, actions);
+    if (rejectedGroupId !== void 0) {
+      const rejectedSection = this.surfaceMetadata?.fieldInteractions.find(
+        (group) => group.groupId === rejectedGroupId
+      )?.sectionId;
+      if (rejectedSection !== void 0) {
+        editing = { ...editing, viewedSectionId: rejectedSection };
+      }
+    }
+    if (acceptedGroup && editing.dirtyGroupIds.length === 0 && editing.pendingGroupIds.length === 0 && editing.rejectedGroupIds.length === 0) {
+      editing = {
+        ...editing,
+        viewedSectionId: editing.authoritativeSectionId
+      };
+    }
+    this.#replaceSnapshot({
+      actions,
+      editing
+    });
+  }
+  #pendingGroupIds(actions) {
+    return new Set(
+      actions.pendingRequests.flatMap(
+        (pending) => pending.groupId === void 0 ? [] : [pending.groupId]
+      )
+    );
+  }
+  #editingSnapshot(surface = void 0, actions = this.#sessionSnapshot.actions) {
+    const resolvedSurface = surface === void 0 ? this.#sessionSnapshot.surface : surface;
+    if (resolvedSurface === null) {
+      return emptyEditingSnapshot();
+    }
+    const pending = this.#pendingGroupIds(actions);
+    const order = resolvedSurface.fieldInteractions.map(
+      (group) => group.groupId
+    );
+    const ordered = (ids) => {
+      const values = new Set(ids);
+      return [
+        ...order.filter((groupId) => values.delete(groupId)),
+        ...[...values].sort()
+      ];
+    };
+    const rejected = new Set(
+      [...this.#rejectedGroupIds].filter(
+        (groupId) => this.#draftsByGroup.has(groupId)
+      )
+    );
+    const dirty = [...this.#draftsByGroup.keys()].filter(
+      (groupId) => !pending.has(groupId) && !rejected.has(groupId)
+    );
+    const authoritative = resolvedSurface.sectionNavigation?.activeSectionId ?? null;
+    const authoritativeChanged = authoritative !== this.#sessionSnapshot.editing.authoritativeSectionId;
+    const viewed = this.#sessionSnapshot.editing.viewedSectionId;
+    const viewedStillAvailable = viewed !== null && (viewed === authoritative || (resolvedSurface.sectionNavigation?.completedSectionIds.includes(
+      viewed
+    ) ?? false));
+    const preserveView = dirty.length > 0 || pending.size > 0 || rejected.size > 0;
+    return {
+      authoritativeSectionId: authoritative,
+      viewedSectionId: preserveView || !authoritativeChanged && viewedStillAvailable ? viewed ?? authoritative : authoritative,
+      dirtyGroupIds: ordered(dirty),
+      pendingGroupIds: ordered(pending),
+      rejectedGroupIds: ordered(rejected)
+    };
+  }
+  #groupIsComplete(surface, group, values) {
+    const descriptors = new Map(
+      this.#adapter.getSurfaceStructure(surface.surfaceId).fields.map((field) => [field.componentId, field])
+    );
+    return group.fields.every((binding) => {
+      const descriptor = descriptors.get(binding.componentId);
+      const value = values[binding.field];
+      return descriptor?.field === binding.field && isFieldValue3(value) && (!descriptor.required || !isIncompleteRequiredValue(value));
+    });
+  }
+  #reconcileDrafts(envelope, surface) {
+    if (surface === null) {
+      this.#clearDrafts();
+      return;
+    }
+    const incoming = envelopeRootFieldValues(envelope);
+    const presentGroups = new Set(
+      surface.fieldInteractions.map((group) => group.groupId)
+    );
+    const pending = this.#pendingGroupIds(this.actionState);
+    for (const group of surface.fieldInteractions) {
+      const fields = group.fields.map((binding) => binding.field);
+      const incomingValues = selectFieldValues(incoming, fields);
+      const authoritative = incomingValues ?? this.#authoritativeByGroup.get(group.groupId) ?? this.#adapter.getFieldValues(surface.surfaceId, fields);
+      if (authoritative !== null && authoritative !== void 0) {
+        this.#authoritativeByGroup.set(group.groupId, {
+          ...authoritative
+        });
+      }
+      const draft = this.#draftsByGroup.get(group.groupId);
+      if (draft === void 0) {
+        continue;
+      }
+      if (draft.surfaceId !== surface.surfaceId || !arraysEqual(draft.fields, fields)) {
+        this.#draftsByGroup.delete(group.groupId);
+        this.#rejectedGroupIds.delete(group.groupId);
+        continue;
+      }
+      if (authoritative !== null && authoritative !== void 0 && fieldValuesEqual(draft.values, authoritative, fields) && !pending.has(group.groupId)) {
+        this.#draftsByGroup.delete(group.groupId);
+        this.#rejectedGroupIds.delete(group.groupId);
+        continue;
+      }
+      if (authoritative !== null && authoritative !== void 0 && !pending.has(group.groupId) && !fieldValuesEqual(draft.baseValues, authoritative, fields)) {
+        this.#draftsByGroup.delete(group.groupId);
+        this.#rejectedGroupIds.delete(group.groupId);
+        continue;
+      }
+      this.#adapter.applyFieldValues(surface.surfaceId, draft.values);
+    }
+    for (const groupId of [...this.#authoritativeByGroup.keys()]) {
+      if (!presentGroups.has(groupId)) {
+        this.#authoritativeByGroup.delete(groupId);
+      }
+    }
+    for (const groupId of [...this.#draftsByGroup.keys()]) {
+      if (!presentGroups.has(groupId) && !pending.has(groupId)) {
+        this.#draftsByGroup.delete(groupId);
+        this.#rejectedGroupIds.delete(groupId);
+      }
+    }
+  }
+  #clearDrafts() {
+    this.#draftsByGroup.clear();
+    this.#authoritativeByGroup.clear();
+    this.#rejectedGroupIds.clear();
+    this.#handledActionResultRequestId = void 0;
+  }
+  #handleReconnected = () => {
+    if (this.#closed) {
+      return;
+    }
+    void this.#beginReconnectRestore();
+  };
+  async #beginReconnectRestore() {
+    if (this.#closed) {
+      return;
+    }
+    if (this.#restoreResetsSequence && this.restoring && this.#pendingSnapshotRequestId !== void 0) {
+      return;
+    }
+    this.#pendingSnapshotRequestId = void 0;
+    this.#restoreResetsSequence = true;
+    this.#actionBridge.markReconnect();
+    this.#replaceSnapshot({ restoring: true });
+    await this.#announceCapabilities();
+  }
+  #handleDisconnected = () => {
+    this.stop();
+  };
+  async #announceCapabilities() {
+    if (this.#closed) {
+      return void 0;
+    }
+    let requestId;
+    try {
+      requestId = createCapabilityRequestId();
+    } catch {
+      return void 0;
+    }
+    const envelope = {
+      envelopeVersion: ENVELOPE_VERSION,
+      kind: "capabilities",
+      requestId,
+      role: this.#participantRole,
+      supportedA2uiVersions: [A2UI_PROTOCOL_VERSION],
+      supportedCatalogIds: this.#adapter.supportedCatalogIds,
+      renderer: {
+        name: this.#adapter.rendererName,
+        version: this.#adapter.rendererVersion
+      },
+      requestSnapshot: true
+    };
+    this.#pendingSnapshotRequestId = requestId;
+    const generation = ++this.#capabilityGeneration;
+    try {
+      const encoded = JSON.stringify(envelope);
+      await this.#room.localParticipant.sendText(encoded, {
+        topic: A2UI_CAPABILITIES_TOPIC
+      });
+      this.#scheduleCapabilityRetries(encoded, requestId, generation);
+    } catch {
+      if (this.#pendingSnapshotRequestId === requestId) {
+        this.#pendingSnapshotRequestId = void 0;
+      }
+      return void 0;
+    }
+    return requestId;
+  }
+  #scheduleCapabilityRetries(encoded, requestId, generation) {
+    this.#clearCapabilityRetryTimers();
+    for (const retryAfterMs of this.#capabilityRetryScheduleMs) {
+      const timer = globalThis.setTimeout(() => {
+        if (this.#closed || generation !== this.#capabilityGeneration || this.#pendingSnapshotRequestId !== requestId || !this.#handlerRegistered) {
+          return;
+        }
+        void this.#room.localParticipant.sendText(encoded, { topic: A2UI_CAPABILITIES_TOPIC }).catch(() => void 0);
+      }, retryAfterMs);
+      this.#capabilityRetryTimers.push(timer);
+    }
+  }
+  #clearCapabilityRetryTimers() {
+    for (const timer of this.#capabilityRetryTimers) {
+      globalThis.clearTimeout(timer);
+    }
+    this.#capabilityRetryTimers = [];
+  }
+  #reportInboundError(errorCode, detail) {
+    if (!this.#closed) {
+      this.#adapter.reportClientError(errorCode, void 0, detail);
+    }
+  }
+  #replaceSnapshot(patch) {
+    const nextSurface = patch.surface === void 0 ? this.#sessionSnapshot.surface : patch.surface;
+    const nextEditing = patch.editing ?? editingAfterSurface(this.#sessionSnapshot.editing, patch.surface);
+    this.#sessionSnapshot = {
+      status: patch.status ?? this.#sessionSnapshot.status,
+      restoring: patch.restoring ?? this.#sessionSnapshot.restoring,
+      surface: patch.surface === void 0 ? this.#sessionSnapshot.surface : patch.surface,
+      actions: patch.actions ?? this.#sessionSnapshot.actions,
+      editing: nextSurface === null ? emptyEditingSnapshot() : nextEditing
+    };
+    for (const listener of this.#listeners) {
+      listener();
+    }
+  }
+};
+function createCapabilityRequestId() {
+  return `cap-${globalThis.crypto.randomUUID()}`;
+}
+function cloneSectionNavigation(navigation) {
+  if (navigation === null) {
+    return null;
+  }
+  return {
+    orderedSectionIds: [...navigation.orderedSectionIds],
+    activeSectionId: navigation.activeSectionId,
+    completedSectionIds: [...navigation.completedSectionIds],
+    futureSectionIds: [...navigation.futureSectionIds]
+  };
+}
+function cloneFieldInteractions(groups) {
+  return groups.map((group) => ({
+    groupId: group.groupId,
+    ownerStateId: group.ownerStateId,
+    ...group.sectionId === void 0 ? {} : { sectionId: group.sectionId },
+    mode: group.mode,
+    fields: group.fields.map((field) => ({ ...field }))
+  }));
+}
+function emptyEditingSnapshot() {
+  return {
+    authoritativeSectionId: null,
+    viewedSectionId: null,
+    dirtyGroupIds: [],
+    pendingGroupIds: [],
+    rejectedGroupIds: []
+  };
+}
+function editingAfterSurface(editing, surface) {
+  if (surface === void 0) {
+    return editing;
+  }
+  if (surface === null) {
+    return emptyEditingSnapshot();
+  }
+  const authoritative = surface.sectionNavigation?.activeSectionId ?? null;
+  const viewedStillAvailable = editing.viewedSectionId !== null && (editing.viewedSectionId === authoritative || (surface.sectionNavigation?.completedSectionIds.includes(
+    editing.viewedSectionId
+  ) ?? false));
+  const preserveView = editing.dirtyGroupIds.length > 0 || editing.pendingGroupIds.length > 0 || editing.rejectedGroupIds.length > 0 || editing.authoritativeSectionId === authoritative && viewedStillAvailable;
+  return {
+    ...editing,
+    authoritativeSectionId: authoritative,
+    viewedSectionId: preserveView ? editing.viewedSectionId : authoritative
+  };
+}
+function decodeServerEnvelope(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return invalid("message_malformed", "json_invalid");
+  }
+  if (!isRecord2(value)) {
+    return invalid("message_malformed", "envelope_invalid");
+  }
+  if (value.envelopeVersion !== ENVELOPE_VERSION) {
+    return invalid("envelope_unsupported", "envelope_version_unsupported");
+  }
+  if (value.a2uiVersion !== A2UI_PROTOCOL_VERSION || !isPositiveInteger(value.seq)) {
+    return invalid("envelope_unsupported", "protocol_unsupported");
+  }
+  if (value.kind === "surfaceUpdate" || value.kind === "snapshot") {
+    return decodeSurfaceEnvelope(value, value.kind);
+  }
+  if (value.kind === "ack") {
+    return decodeAckEnvelope(value);
+  }
+  return invalid("envelope_unsupported", "kind_unsupported");
+}
+function decodeSurfaceEnvelope(value, kind) {
+  const allowed = [
+    "envelopeVersion",
+    "a2uiVersion",
+    "kind",
+    "seq",
+    "surfaceId",
+    "revision",
+    "activeStateId",
+    "sectionNavigation",
+    "fieldInteractions",
+    "messages",
+    ...kind === "snapshot" ? ["inResponseTo"] : []
+  ];
+  const required = [
+    "envelopeVersion",
+    "a2uiVersion",
+    "kind",
+    "seq",
+    "surfaceId",
+    "revision",
+    "messages"
+  ];
+  if (!hasExactKeys(value, allowed, required)) {
+    return invalid("envelope_unsupported", "envelope_properties_invalid");
+  }
+  if (!isNonEmptyString2(value.surfaceId) || !isPositiveInteger(value.revision) || "activeStateId" in value && value.activeStateId !== null && !isNonEmptyString2(value.activeStateId) || "inResponseTo" in value && !isNonEmptyString2(value.inResponseTo) || "sectionNavigation" in value && !isSectionNavigation(value.sectionNavigation) || "fieldInteractions" in value && !isFieldInteractions(
+    value.fieldInteractions,
+    value.activeStateId,
+    value.sectionNavigation
+  )) {
+    return invalid("message_malformed", "surface_metadata_invalid");
+  }
+  const parsedMessages = A2uiMessageListSchema2.safeParse(value.messages);
+  if (!parsedMessages.success || parsedMessages.data.length === 0) {
+    return invalid("message_malformed", "messages_invalid");
+  }
+  if (parsedMessages.data.some((message) => {
+    const lifecycle = [
+      "createSurface",
+      "updateComponents",
+      "updateDataModel",
+      "deleteSurface"
+    ].find((key) => key in message);
+    if (lifecycle === void 0) {
+      return true;
+    }
+    const body = message[lifecycle];
+    return body.surfaceId !== value.surfaceId;
+  })) {
+    return invalid("message_malformed", "message_surface_mismatch");
+  }
+  return {
+    ok: true,
+    envelope: value
+  };
+}
+var SERVER_REASON_CODES = /* @__PURE__ */ new Set([
+  "envelope_version_unsupported",
+  "a2ui_version_unsupported",
+  "catalog_unsupported",
+  "role_unauthorized",
+  "surface_unknown",
+  "state_mismatch",
+  "revision_stale",
+  "request_duplicate",
+  "action_disallowed",
+  "field_unknown",
+  "value_invalid",
+  "payload_malformed",
+  "envelope_too_large"
+]);
+function decodeAckEnvelope(value) {
+  const allowed = [
+    "envelopeVersion",
+    "a2uiVersion",
+    "kind",
+    "seq",
+    "inResponseTo",
+    "status",
+    "reasonCode",
+    "fieldErrors",
+    "noSurface"
+  ];
+  const required = [
+    "envelopeVersion",
+    "a2uiVersion",
+    "kind",
+    "seq",
+    "inResponseTo",
+    "status"
+  ];
+  if (!hasExactKeys(value, allowed, required)) {
+    return invalid("envelope_unsupported", "envelope_properties_invalid");
+  }
+  if (!isNonEmptyString2(value.inResponseTo) || value.status !== "accepted" && value.status !== "rejected" || value.status === "accepted" && "reasonCode" in value || value.status === "rejected" && (!isNonEmptyString2(value.reasonCode) || !SERVER_REASON_CODES.has(value.reasonCode)) || "noSurface" in value && typeof value.noSurface !== "boolean" || "fieldErrors" in value && !isFieldErrors(value.fieldErrors)) {
+    return invalid("message_malformed", "ack_invalid");
+  }
+  return {
+    ok: true,
+    envelope: value
+  };
+}
+function isFieldErrors(value) {
+  return Array.isArray(value) && value.every(
+    (entry) => isRecord2(entry) && hasExactKeys(entry, ["field", "reasonCode"], ["field", "reasonCode"]) && isNonEmptyString2(entry.field) && isNonEmptyString2(entry.reasonCode) && SERVER_REASON_CODES.has(entry.reasonCode)
+  );
+}
+function isSectionNavigation(value) {
+  if (!isRecord2(value) || !hasExactKeys(
+    value,
+    [
+      "orderedSectionIds",
+      "activeSectionId",
+      "completedSectionIds",
+      "futureSectionIds"
+    ],
+    [
+      "orderedSectionIds",
+      "activeSectionId",
+      "completedSectionIds",
+      "futureSectionIds"
+    ]
+  ) || !isNonEmptyStringArray(value.orderedSectionIds) || value.orderedSectionIds.length === 0 || new Set(value.orderedSectionIds).size !== value.orderedSectionIds.length || value.activeSectionId !== null && !isNonEmptyString2(value.activeSectionId) || !isNonEmptyStringArray(value.completedSectionIds) || !isNonEmptyStringArray(value.futureSectionIds) || new Set(value.completedSectionIds).size !== value.completedSectionIds.length || new Set(value.futureSectionIds).size !== value.futureSectionIds.length) {
+    return false;
+  }
+  const orderedSectionIds = value.orderedSectionIds;
+  const completedSectionIds = value.completedSectionIds;
+  const futureSectionIds = value.futureSectionIds;
+  const activeSectionId = value.activeSectionId;
+  const classified = [
+    ...completedSectionIds,
+    ...futureSectionIds,
+    ...activeSectionId === null ? [] : [activeSectionId]
+  ];
+  return new Set(classified).size === classified.length && classified.length === orderedSectionIds.length && classified.every(
+    (sectionId) => orderedSectionIds.includes(sectionId)
+  ) && arraysEqual(
+    completedSectionIds,
+    orderedSectionIds.filter(
+      (sectionId) => completedSectionIds.includes(sectionId)
+    )
+  ) && arraysEqual(
+    futureSectionIds,
+    orderedSectionIds.filter(
+      (sectionId) => futureSectionIds.includes(sectionId)
+    )
+  );
+}
+function isFieldInteractions(value, activeStateId, navigationValue) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return false;
+  }
+  const navigation = isSectionNavigation(navigationValue) ? navigationValue : null;
+  const groupIds = /* @__PURE__ */ new Set();
+  const fields = /* @__PURE__ */ new Set();
+  const componentIds = /* @__PURE__ */ new Set();
+  let currentCount = 0;
+  for (const group of value) {
+    if (!isRecord2(group) || !hasExactKeys(
+      group,
+      ["groupId", "ownerStateId", "sectionId", "mode", "fields"],
+      ["groupId", "ownerStateId", "mode", "fields"]
+    ) || !isNonEmptyString2(group.groupId) || !isNonEmptyString2(group.ownerStateId) || group.mode !== "current" && group.mode !== "revision" || !Array.isArray(group.fields) || group.fields.length === 0 || groupIds.has(group.groupId)) {
+      return false;
+    }
+    groupIds.add(group.groupId);
+    if (group.mode === "current") {
+      currentCount += 1;
+      if (group.ownerStateId !== activeStateId) {
+        return false;
+      }
+    } else if (group.ownerStateId === activeStateId) {
+      return false;
+    }
+    if ("sectionId" in group) {
+      if (!isNonEmptyString2(group.sectionId) || navigation === null || !navigation.orderedSectionIds.includes(group.sectionId) || group.mode === "current" && group.sectionId !== navigation.activeSectionId || group.mode === "revision" && group.sectionId !== navigation.activeSectionId && !navigation.completedSectionIds.includes(group.sectionId)) {
+        return false;
+      }
+    }
+    for (const binding of group.fields) {
+      if (!isRecord2(binding) || !hasExactKeys(
+        binding,
+        ["field", "componentId"],
+        ["field", "componentId"]
+      ) || !isNonEmptyString2(binding.field) || !isNonEmptyString2(binding.componentId) || fields.has(binding.field) || componentIds.has(binding.componentId)) {
+        return false;
+      }
+      fields.add(binding.field);
+      componentIds.add(binding.componentId);
+    }
+  }
+  return currentCount <= 1;
+}
+function isNonEmptyStringArray(value) {
+  return Array.isArray(value) && value.every(isNonEmptyString2);
+}
+function arraysEqual(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function fieldValuesEqual(left, right, fields) {
+  return fields.every(
+    (field) => Object.hasOwn(left, field) && Object.hasOwn(right, field) && Object.is(left[field], right[field])
+  );
+}
+function isFieldValue3(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function isIncompleteRequiredValue(value) {
+  return value === null || typeof value === "string" && value.trim() === "";
+}
+function envelopeRootFieldValues(envelope) {
+  let values = null;
+  for (const message of envelope.messages) {
+    if (!isRecord2(message) || !isRecord2(message.updateDataModel)) {
+      continue;
+    }
+    const update = message.updateDataModel;
+    if (update.surfaceId !== envelope.surfaceId || update.path !== void 0 && update.path !== "/" || !isRecord2(update.value)) {
+      continue;
+    }
+    const candidate = {};
+    for (const [field, value] of Object.entries(update.value)) {
+      if (isFieldValue3(value)) {
+        candidate[field] = value;
+      }
+    }
+    values = candidate;
+  }
+  return values;
+}
+function selectFieldValues(source, fields) {
+  if (source === null) {
+    return null;
+  }
+  const selected = {};
+  for (const field of fields) {
+    if (!Object.hasOwn(source, field)) {
+      return null;
+    }
+    selected[field] = source[field] ?? null;
+  }
+  return selected;
+}
+function hasExactKeys(value, allowed, required) {
+  const keys = Object.keys(value);
+  return keys.every((key) => allowed.includes(key)) && required.every((key) => Object.hasOwn(value, key));
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && typeof value === "number" && value > 0;
+}
+function invalid(errorCode, detail) {
+  return { ok: false, errorCode, detail };
+}
+
+// src/join.ts
+async function joinA2UIRoom(tokenProvider) {
+  let material;
+  try {
+    material = await tokenProvider();
+  } catch {
+    throw new Error("A2UI room runtime material is unavailable.");
+  }
+  if (!isValidRuntimeMaterial(material)) {
+    throw new Error("A2UI room runtime material is invalid.");
+  }
+  let room;
+  try {
+    const { Room } = await import("livekit-client");
+    room = new Room();
+  } catch {
+    throw new Error("Unable to initialize the A2UI room.");
+  }
+  try {
+    await room.connect(material.serverUrl, material.token);
+  } catch {
+    try {
+      await room.disconnect();
+    } catch {
+    }
+    throw new Error("Unable to join the A2UI room.");
+  }
+  let closePromise;
+  return {
+    room,
+    close() {
+      closePromise ??= disconnectWithoutLeaking(room);
+      return closePromise;
+    }
+  };
+}
+function isValidRuntimeMaterial(material) {
+  if (typeof material !== "object" || material === null || typeof material.serverUrl !== "string" || material.serverUrl.length === 0 || typeof material.token !== "string" || material.token.length === 0) {
+    return false;
+  }
+  try {
+    const protocol = new URL(material.serverUrl).protocol;
+    return ["wss:", "ws:", "https:", "http:"].includes(protocol);
+  } catch {
+    return false;
+  }
+}
+async function disconnectWithoutLeaking(room) {
+  try {
+    await room.disconnect();
+  } catch {
+  }
+}
+export {
+  A2UIClientAdapter,
+  A2UISessionController,
+  A2UISurfaceHost,
+  A2UI_CAPABILITIES_TOPIC,
+  A2UI_CLIENT_TOPIC,
+  A2UI_PROTOCOL_VERSION,
+  A2UI_SERVER_TOPIC,
+  CLIENT_ACTIONS,
+  CLIENT_ERROR_CODES,
+  ENVELOPE_VERSION,
+  MAX_ENVELOPE_BYTES,
+  joinA2UIRoom
+};
+//# sourceMappingURL=index.js.map