@beyondwork/docx-react-component 1.0.66 → 1.0.69

package/src/api/v3/ai/policy.ts

@@ -0,0 +1,77 @@
+/**
+ * @endStateApi v3 — `ai.policy` family.
+ *
+ * getPolicy — agent-facing view of the AI action policy matrix.
+ *
+ * Thin adapter over Layer-06's `src/runtime/workflow/ai-action-policy.ts`
+ * — the 23-operation matrix that gates AI mutations per capability +
+ * risk tier. Exposed on v3 so agents + workblocks can pre-check whether
+ * a given action requires confirmation / carries approval requirements /
+ * is blocked outright, without having to call
+ * `ai.validateReplacementScope` just to learn the policy state.
+ *
+ * `validateReplacementScope` still internally consumes the same policy
+ * matrix (through `composeScopeValidation` in /08); this function is a
+ * pre-flight read-only surface. A4 audit emission does NOT apply here —
+ * `readOrMutate: "read"`.
+ *
+ * Cross-layer-coord history: filed by /06 §7 "L09 expose AI action
+ * policy matrix" (2026-04-22). Closes that ask.
+ */
+
+import type { RuntimeApiHandle } from "../_runtime-handle.ts";
+import type { ApiV3FnMetadata } from "../_layer-metadata.ts";
+import {
+  AI_ACTION_POLICIES,
+  getAIActionPolicy,
+  type AIAction,
+  type AIActionPolicy,
+} from "../../../runtime/workflow/ai-action-policy.ts";
+
+export interface GetPolicyInput {
+  /**
+   * When set, return the single policy for that action. When omitted,
+   * return the full matrix.
+   */
+  readonly action?: AIAction;
+}
+
+export type GetPolicyResult = AIActionPolicy | readonly AIActionPolicy[];
+
+export const getPolicyMetadata: ApiV3FnMetadata = {
+  name: "ai.getPolicy",
+  status: "live-with-adapter",
+  sourceLayer: "workflow-review",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ai/ai-get-policy.test.ts",
+    commit: "refactor-09-slice-6",
+  },
+  uxIntent: { uiVisible: false, expectsUxResponse: "none" },
+  agentMetadata: {
+    readOrMutate: "read",
+    boundedScope: "document",
+    auditCategory: "policy-read",
+    contextPromptShape:
+      "Pre-flight view of the AI action policy matrix — for a given action: support tier (allowed / confirmation-required / blocked), risk tier (low / medium / high / critical), rationale, requirements (confirmation, preservation, validation, audit), constraints (scope, preservation respect, compatibility, undo), fallback. Omit action to get the full matrix.",
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  rwdReference:
+    "§AI API § ai.getPolicy. Adapter: delegates to getAIActionPolicy(action) or surfaces AI_ACTION_POLICIES[] directly. Read-only; no audit emission (A4 applies to mutations). Closes cross-layer-coord-06.md §7 (L09 expose AI action policy matrix).",
+};
+
+export function createPolicyFamily(_runtime: RuntimeApiHandle) {
+  return {
+    getPolicy(input?: GetPolicyInput): GetPolicyResult {
+      // @endStateApi — live-with-adapter. Delegates to Layer-06's
+      // getAIActionPolicy(action) for single-action lookups or returns
+      // the frozen AI_ACTION_POLICIES matrix for bulk listing. The
+      // runtime handle is accepted for API-shape consistency but is
+      // not read — the policy matrix is process-wide static.
+      if (input?.action) {
+        return getAIActionPolicy(input.action);
+      }
+      return AI_ACTION_POLICIES;
+    },
+  };
+}

package/src/api/v3/ai/replacement.ts

@@ -0,0 +1,341 @@
+/**
+ * @endStateApi v3 — `ai.replacement` family.
+ *
+ * - `proposeReplacementScope` / `applyReplacementScope` stay `mock` until
+ *   refactor/08 Slice 5 ships the replacement lifecycle (propose →
+ *   compile → apply + audit).
+ * - `validateReplacementScope` graduated to `live-with-adapter` in
+ *   Slice 4: compiles the target scope fresh, runs
+ *   `composeScopeValidation`, and projects the richer compiler verdict
+ *   into the v3-facing `ValidationResult` shape.
+ *
+ * The v3 `ValidationResult` shape (`{ proposalId, safe, blockers? }`)
+ * stays narrow by design. The compiler-side `ValidationResult`
+ * (`{ safe, blockedReasons, warnings, approval }`) remains the authority
+ * for internal consumers; the v3 projection trades richness for a
+ * stable external contract. Slice 5's apply pipeline reads the
+ * compiler verdict directly rather than the v3 projection.
+ */
+
+import type { RuntimeApiHandle } from "../_runtime-handle.ts";
+import type { ApiV3FnMetadata } from "../_layer-metadata.ts";
+import { mockId } from "../_mocks.ts";
+import { emitUxResponse } from "../_ux-response.ts";
+import {
+  composeScopeValidation,
+  createScopeCompilerService,
+} from "../../../runtime/scopes/index.ts";
+import type {
+  ReplacementOperationKind,
+  ReplacementPreservePolicy,
+  ValidationResult as CompilerValidationResult,
+} from "../../../runtime/scopes/index.ts";
+import type { AIAction } from "../../../runtime/workflow/ai-action-policy.ts";
+
+export interface ReplacementProposalInput {
+  readonly targetScopeId: string;
+  readonly operation: ReplacementOperationKind;
+  readonly proposedText?: string;
+  readonly preserve?: ReplacementPreservePolicy;
+  readonly reason?: string;
+  readonly actionId?: AIAction;
+}
+
+/**
+ * @deprecated retained for back-compat with pre-Slice-5 callers;
+ * mirrors {@link ReplacementProposalInput} but without the broadened fields.
+ * @see ReplacementProposalInput
+ */
+export type ReplacementProposal = Pick<
+  ReplacementProposalInput,
+  "targetScopeId" | "operation" | "proposedText"
+>;
+
+export interface ProposalResult {
+  readonly proposalId: string;
+  readonly accepted: boolean;
+}
+
+export const proposeReplacementScopeMetadata: ApiV3FnMetadata = {
+  name: "ai.proposeReplacementScope",
+  status: "live-with-adapter",
+  sourceLayer: "semantic-scope-compiler",
+  liveEvidence: {
+    runnerTest:
+      "test/runtime/scopes/replacement-text-only.test.ts,test/api/v3/ai/live-with-adapter-proof.test.ts",
+    commit: "refactor-08-slice-5",
+  },
+  uxIntent: { uiVisible: false, expectsUxResponse: "none" },
+  agentMetadata: {
+    readOrMutate: "read",
+    boundedScope: "scope",
+    auditCategory: "replacement-propose",
+    contextPromptShape: "Propose scope-scoped replacement; returns a proposalId + accepted flag. No propose-cache persists — apply re-compiles fresh.",
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  rwdReference:
+    "§AI API § ai.proposeReplacementScope. Adapter: resolves targetScopeId against live state; returns {proposalId, accepted: scope resolves successfully}.",
+};
+
+/**
+ * v3-facing validation result. Narrower than the compiler-side
+ * `ValidationResult` (`{safe, blockedReasons, warnings, approval}`) —
+ * Slice 4 projects the compiler verdict into this shape so external
+ * consumers (workblocks, MCP, BW agent surface) get a stable contract.
+ */
+export interface ValidationResult {
+  readonly proposalId: string;
+  readonly safe: boolean;
+  readonly blockers?: readonly string[];
+  readonly warnings?: readonly string[];
+  readonly approvalRequired?: boolean;
+  readonly approvalReason?: string;
+}
+
+export const validateReplacementScopeMetadata: ApiV3FnMetadata = {
+  name: "ai.validateReplacementScope",
+  status: "live-with-adapter",
+  sourceLayer: "semantic-scope-compiler",
+  liveEvidence: {
+    runnerTest:
+      "test/runtime/scopes/validation-all-green.test.ts,test/runtime/scopes/validation-guard-blocks.test.ts,test/runtime/scopes/validation-preserve-only.test.ts,test/runtime/scopes/validation-compat-risk.test.ts,test/runtime/scopes/validation-approval-required.test.ts,test/runtime/scopes/validation-source-tagging.test.ts,test/runtime/scopes/validation-determinism.test.ts,test/api/v3/ai-live-with-adapter-proof.test.ts",
+    commit: "refactor-08-slice-4",
+  },
+  uxIntent: { uiVisible: false, expectsUxResponse: "none" },
+  agentMetadata: {
+    readOrMutate: "read",
+    boundedScope: "scope",
+    auditCategory: "replacement-validate",
+    contextPromptShape:
+      "Validate a scope-scoped replacement against workflow guard + preservation boundaries + compatibility report + AI action policy.",
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  rwdReference: "§AI API § ai.validateReplacementScope",
+};
+
+export interface ApplyResult {
+  readonly proposalId: string;
+  readonly applied: boolean;
+  readonly reason?: string;
+  readonly blockers?: readonly string[];
+  readonly auditHint?: string;
+}
+
+export interface ApplyReplacementScopeInput {
+  readonly targetScopeId: string;
+  readonly operation?: ReplacementOperationKind;
+  /**
+   * Flat text payload. Shorthand for
+   * `proposedContent: {kind: "text", text}`. Ignored when
+   * `proposedContent` is supplied.
+   */
+  readonly proposedText?: string;
+  /**
+   * Structured-fragment payload (`kind: "structured"` with a
+   * `CanonicalDocumentFragment`-shaped value). Widens the v3 surface
+   * 2026-04-22 — v3 consumers can now pass a structured fragment
+   * end-to-end. Closes `cross-layer-coord-09.md §1.5` on the L08 side.
+   */
+  readonly proposedContent?: {
+    readonly kind: "text" | "structured";
+    readonly text?: string;
+    readonly structured?: unknown;
+  };
+  readonly preserve?: ReplacementPreservePolicy;
+  readonly reason?: string;
+  readonly actionId?: AIAction;
+  readonly actorId?: string;
+  readonly origin?: "ui" | "agent" | "host";
+  readonly proposalId?: string;
+}
+
+export const applyReplacementScopeMetadata: ApiV3FnMetadata = {
+  name: "ai.applyReplacementScope",
+  status: "live-with-adapter",
+  sourceLayer: "semantic-scope-compiler",
+  liveEvidence: {
+    runnerTest:
+      "test/runtime/scopes/replacement-text-only.test.ts,test/runtime/scopes/audit-bundle-shape.test.ts,test/runtime/scopes/replacement-validation-block.test.ts",
+    commit: "refactor-08-slice-5",
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "text inside target scope changes",
+  },
+  agentMetadata: {
+    readOrMutate: "mutate",
+    boundedScope: "scope",
+    auditCategory: "replacement-apply",
+    policyHints: ["requires-approval-for-legal-hold"],
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  broadcastsVia: "crdt",
+  rwdReference:
+    "§AI API § ai.applyReplacementScope. Adapter: widened to {targetScopeId, operation, proposedText?, preserve?, actionId?, proposalId?}; routes through applyScopeReplacement (re-validates live state, compiles per-kind plan, dispatches via DocumentRuntime.applyScopeReplacement, emits one ScopeActionAudit on the scope telemetry channel).",
+};
+
+/**
+ * Input shape for `validateReplacementScope`. Slice 4 widens the input
+ * to carry enough information for a fresh compile + compose, since the
+ * propose-cache that Slice 5 introduces is not yet available. Legacy
+ * callers passing only `{ proposalId }` get a typed "propose-cache-not-
+ * available" response (no mutation, no false positives).
+ */
+export interface ValidateReplacementScopeInput {
+  readonly proposalId?: string;
+  readonly targetScopeId?: string;
+  readonly operation?: ReplacementOperationKind;
+  readonly proposedText?: string;
+  /** Optional action id override; composer derives a default otherwise. */
+  readonly actionId?: AIAction;
+}
+
+function projectValidationResult(
+  proposalId: string,
+  verdict: CompilerValidationResult,
+): ValidationResult {
+  const blockers =
+    verdict.blockedReasons.length > 0
+      ? Object.freeze([...verdict.blockedReasons])
+      : undefined;
+  const warnings =
+    verdict.warnings.length > 0
+      ? Object.freeze(verdict.warnings.map((w) => w.code))
+      : undefined;
+  return {
+    proposalId,
+    safe: verdict.safe,
+    ...(blockers ? { blockers } : {}),
+    ...(warnings ? { warnings } : {}),
+    ...(verdict.approval?.required ? { approvalRequired: true } : {}),
+    ...(verdict.approval?.reason ? { approvalReason: verdict.approval.reason } : {}),
+  };
+}
+
+export function createReplacementFamily(runtime: RuntimeApiHandle) {
+  const compiler = createScopeCompilerService(runtime);
+  return {
+    proposeReplacementScope(input: ReplacementProposalInput): ProposalResult {
+      // @endStateApi — live-with-adapter (Slice 5). Routes through the
+      // Layer-08 compiler-service facade.
+      const proposalId = mockId(
+        runtime.getSessionState().documentId,
+        `proposal-${input.targetScopeId}-${input.operation}`,
+      );
+      const compiled = compiler.compileScopeById(input.targetScopeId);
+      return { proposalId, accepted: compiled !== null };
+    },
+
+    validateReplacementScope(
+      input: ValidateReplacementScopeInput,
+    ): ValidationResult {
+      // @endStateApi — live-with-adapter. Compiles via the facade and
+      // composes the verdict locally (v3 projects the compiler-side
+      // verdict into a narrower external shape).
+      const proposalId =
+        input.proposalId ??
+        (input.targetScopeId
+          ? mockId(
+              runtime.getSessionState().documentId,
+              `validation-${input.targetScopeId}-${input.operation ?? "replace"}`,
+            )
+          : "unresolved-proposal");
+
+      if (!input.targetScopeId) {
+        return {
+          proposalId,
+          safe: false,
+          blockers: Object.freeze([
+            "legacy-proposalId-only:pass-targetScopeId-to-validate-now",
+          ]),
+        };
+      }
+
+      const compiled = compiler.compileScopeById(input.targetScopeId);
+      if (!compiled) {
+        return {
+          proposalId,
+          safe: false,
+          blockers: Object.freeze([
+            `scope-not-resolvable:${input.targetScopeId}`,
+          ]),
+        };
+      }
+
+      const operation: ReplacementOperationKind = input.operation ?? "replace";
+      const proposedContent =
+        typeof input.proposedText === "string"
+          ? ({ kind: "text", text: input.proposedText } as const)
+          : ({ kind: "text", text: "" } as const);
+
+      const verdict = composeScopeValidation({
+        scope: compiled.scope,
+        operation,
+        proposedContent,
+        runtime: {
+          getInteractionGuardSnapshot: () => runtime.getInteractionGuardSnapshot(),
+          getCompatibilityReport: () => runtime.getCompatibilityReport(),
+        },
+        document: compiled.document,
+        ...(input.actionId ? { actionId: input.actionId } : {}),
+      });
+      return projectValidationResult(proposalId, verdict);
+    },
+
+    applyReplacementScope(input: ApplyReplacementScopeInput): ApplyResult {
+      // @endStateApi — live-with-adapter (Slice 5). Routes through the
+      // compiler-service facade. The facade re-validates on live state,
+      // compiles the per-kind plan, dispatches via
+      // DocumentRuntime.applyScopeReplacement, and emits one
+      // ScopeActionAudit on the scope telemetry channel.
+      const proposalId =
+        input.proposalId ??
+        mockId(
+          runtime.getSessionState().documentId,
+          `apply-${input.targetScopeId}-${input.operation ?? "replace"}`,
+        );
+
+      const result = compiler.applyReplacement({
+        targetScopeId: input.targetScopeId,
+        operation: input.operation ?? "replace",
+        ...(input.proposedContent
+          ? { proposedContent: input.proposedContent }
+          : input.proposedText !== undefined
+            ? { proposedText: input.proposedText }
+            : {}),
+        ...(input.preserve ? { preserve: input.preserve } : {}),
+        ...(input.reason ? { reason: input.reason } : {}),
+        ...(input.actionId ? { actionId: input.actionId } : {}),
+        actorId: input.actorId ?? "agent",
+        origin: input.origin ?? "agent",
+        emittedAtUtc: new Date(0).toISOString(),
+      });
+
+      emitUxResponse(runtime, {
+        apiFn: applyReplacementScopeMetadata.name,
+        intent: applyReplacementScopeMetadata.uxIntent.expectedDelta ?? "",
+        mockOrLive: "live",
+        uiVisible: true,
+        expectedDelta: applyReplacementScopeMetadata.uxIntent.expectedDelta,
+      });
+
+      return {
+        proposalId,
+        applied: result.applied,
+        ...(result.reason ? { reason: result.reason } : {}),
+        ...(result.validation.blockedReasons.length > 0
+          ? { blockers: Object.freeze([...result.validation.blockedReasons]) }
+          : {}),
+        ...(result.audit ? { auditHint: result.audit.actionId } : {}),
+      };
+    },
+  };
+}
+
+// Silence unused-import: ReplacementPreservePolicy is a public re-export
+// for consumers of this module's input types.
+export type { ReplacementPreservePolicy };

package/src/api/v3/ai/resolve.ts

@@ -0,0 +1,133 @@
+/**
+ * @endStateApi v3 — `ai.resolve` family.
+ *
+ * Slice 3 of refactor/08 graduates `resolveReference` to
+ * `live-with-adapter` for the FOUR DETERMINISTIC hint kinds: `scope-id`,
+ * `semantic-path`, `offset`, and `range`. Offset / range resolution now
+ * honors precise nested-kind ranges (fields, table rows, table cells)
+ * via the scope-compiler's specificity tie-breaker — see
+ * `docs/architecture/08-semantic-scope-compiler.md` §"Resolve-reference
+ * precision" for the specificity table.
+ *
+ * The `natural-language` hint remains **partial by design**. The live
+ * path is a deterministic substring matcher over:
+ *   - `semanticPath.join("/")`
+ *   - `scopeId`
+ *   - `overlay.scopes[].label` (when the overlay is threaded)
+ *   - a capped 200-char content excerpt
+ * Every successful NL resolution carries `confidence: "low"` — callers
+ * must surface that to a human before committing any mutating action
+ * keyed off the resolved handle. Richer NL resolution (embedding /
+ * domain-aware) is explicitly out of scope for this layer; the v3
+ * `resolveReference` adapter never promotes an NL match above `low`.
+ */
+
+import type { RuntimeApiHandle } from "../_runtime-handle.ts";
+import {
+  resolveReference,
+  type ResolveReferenceResult as RuntimeResolveResult,
+  type ScopeHandle,
+  type ScopeReference,
+} from "../../../runtime/scopes/index.ts";
+import type { ApiV3FnMetadata } from "../_layer-metadata.ts";
+
+export type ResolveReferenceInput =
+  | { readonly hint: string }
+  | { readonly reference: ScopeReference };
+
+/**
+ * v3 projection of the runtime resolver's result. Carries the FULL
+ * `ScopeHandle` (not just `scopeId`) so callers can round-trip
+ * `stableRef` / `semanticPath` / `parentScopeId` back into a follow-up
+ * `resolveReference` or `getScopeBundle` call.
+ */
+export interface ResolveReferenceResult {
+  readonly status: RuntimeResolveResult["status"];
+  readonly handle?: ScopeHandle;
+  /** Convenience mirror of `handle.scopeId`; also set on `detached`. */
+  readonly scopeId?: string;
+  readonly confidence: "high" | "medium" | "low" | "none";
+  readonly candidates?: readonly ScopeHandle[];
+  readonly reason?: string;
+  readonly lastKnownRange?: { readonly from: number; readonly to: number };
+}
+
+export const resolveReferenceMetadata: ApiV3FnMetadata = {
+  name: "ai.resolveReference",
+  status: "live-with-adapter",
+  sourceLayer: "semantic-scope-compiler",
+  liveEvidence: {
+    runnerTest:
+      "test/runtime/scopes/resolve-reference.test.ts,test/runtime/scopes/resolve-reference-stale-scope.test.ts",
+    commit: "refactor-08-slice-3",
+  },
+  uxIntent: { uiVisible: false, expectsUxResponse: "none" },
+  agentMetadata: {
+    readOrMutate: "read",
+    boundedScope: "document",
+    auditCategory: "reference-resolve",
+    contextPromptShape:
+      "Resolve a natural-language hint or structured ScopeReference into a stable scopeId.",
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  rwdReference: "§AI API § ai.resolveReference",
+};
+
+function asReference(input: ResolveReferenceInput): ScopeReference {
+  if ("reference" in input) return input.reference;
+  return { kind: "natural-language", hint: input.hint };
+}
+
+function projectResult(raw: RuntimeResolveResult): ResolveReferenceResult {
+  switch (raw.status) {
+    case "resolved":
+      return {
+        status: "resolved",
+        handle: raw.handle,
+        scopeId: raw.handle.scopeId,
+        confidence: raw.confidence,
+      };
+    case "ambiguous":
+      return {
+        status: "ambiguous",
+        confidence: "low",
+        candidates: raw.candidates,
+      };
+    case "detached":
+      return {
+        status: "detached",
+        scopeId: raw.scopeId,
+        confidence: "none",
+        reason: raw.reason,
+        ...(raw.lastKnownRange
+          ? {
+              lastKnownRange: {
+                from: raw.lastKnownRange.from,
+                to: raw.lastKnownRange.to,
+              },
+            }
+          : {}),
+      };
+    case "not-found":
+      return { status: "not-found", confidence: "none", reason: raw.reason };
+  }
+}
+
+export function createResolveFamily(runtime: RuntimeApiHandle) {
+  return {
+    resolveReference(input: ResolveReferenceInput): ResolveReferenceResult {
+      // @endStateApi — live-with-adapter. Delegates to the scope-compiler
+      // `resolveReference` over the typed ScopeReference union; NL hints
+      // stay at confidence "low" per Slice 3.
+      const reference = asReference(input);
+      if (reference.kind === "natural-language" && reference.hint.trim().length === 0) {
+        return { status: "not-found", confidence: "none", reason: "empty hint" };
+      }
+      const document = runtime.getCanonicalDocument();
+      const overlay = runtime.getWorkflowOverlay();
+      const raw = resolveReference(reference, { document, overlay });
+      return projectResult(raw);
+    },
+  };
+}

package/src/api/v3/index.ts

@@ -0,0 +1,79 @@
+/**
+ * @endStateApi v3 — public barrel.
+ *
+ * Consumers import ONLY `createApiV3` and the metadata primitives from this
+ * module. Family functions are NOT re-exported as bare names — the
+ * `ci-check-api-v3-no-ref-reexport` guard rejects any convenience barrel
+ * that exposes pre-v3 ref behavior through a v3-shaped name.
+ *
+ * Canonical consumer path:
+ *
+ *   import { createApiV3 } from "@beyondwork/docx-react-component/api/v3";
+ *   const api = createApiV3(runtime);
+ */
+
+export { createApiV3 } from "./_create.ts";
+export type { ApiV3, CreateApiV3Opts } from "./_create.ts";
+
+export type {
+  ApiStatus,
+  SourceLayer,
+  LiveEvidence,
+  MockShape,
+  UxIntent,
+  AgentMetadata,
+  ApiV3FnMetadata,
+  MockPayload,
+  SubscriptionShape,
+  StateClass,
+  PersistsTo,
+  BroadcastsVia,
+} from "./_layer-metadata.ts";
+export { validateApiV3Metadata } from "./_layer-metadata.ts";
+export { isMock, mockPayload, mockArray, mockId } from "./_mocks.ts";
+
+export type { UxResponse } from "./_ux-response.ts";
+export { emitUxResponse } from "./_ux-response.ts";
+
+// Layer 10 — UI API. `createApiV3(handle, { ui: factory })` is the
+// production construction path (refactor/07 Slice 2). `createUiApi` is
+// re-exported so callers that already hold a constructed runtime and
+// want only the UI surface (e.g. a debug harness that built `api` first
+// and needs to add UI later) can construct it standalone.
+//
+// Consumers that treat v3 as a runtime+AI seam (services/debug, headless
+// agents) should keep using `createApiV3(handle)` — `ui` stays undefined.
+// Consumers that mount a React surface pass `{ ui: factory }` and get a
+// typed UI namespace on `api.ui`.
+export { createUiApi } from "./ui/index.ts";
+export type {
+  ApiV3Ui,
+  ApiV3UiSession,
+  ApiV3UiSurface,
+  ApiV3UiViewport,
+  ApiV3UiOverlays,
+  ApiV3UiChrome,
+  ApiV3UiDebug,
+  UiController,
+  UiControllerKind,
+  UiControllerFactory,
+  UiBinding,
+  UiListener,
+  UiUnsubscribe,
+  ViewportState,
+  ScrollTarget,
+  ScrollTargetBehavior,
+  SelectionRangeInput,
+  OverlayAnchorQuery,
+  ChromePosture,
+  ChromeHostPosture,
+  ChromeSurface,
+  ChromeSurfaceKind,
+  ChromeDocumentMode,
+  ChromeMarkupDisplay,
+  ChromeReviewMode,
+  ChromeDebugMode,
+  DebugSession,
+  DebugAttachment,
+  GeometryRect,
+} from "./ui/index.ts";