@termwright/probe-ink 0.2.0 → 0.3.1

package/dist/chunk-Q75BSILO.js

@@ -0,0 +1,649 @@
+import {
+  INK_VERSION,
+  instrumentationSentinel
+} from "./chunk-SLKX554P.js";
+
+// src/react-commit-bridge.ts
+var BRIDGE = /* @__PURE__ */ Symbol.for("@termwright/probe-ink/react-commit-bridge.v1");
+var ReactCommitBridge = class {
+  #renderers = /* @__PURE__ */ new Map();
+  #roots = /* @__PURE__ */ new Map();
+  #listeners = /* @__PURE__ */ new Set();
+  #nextRendererId = 1;
+  register(renderer, delegatedId) {
+    const rendererId = delegatedId === void 0 ? this.#nextRendererId++ : delegatedId;
+    if (typeof rendererId === "number" && Number.isInteger(rendererId)) {
+      this.#nextRendererId = Math.max(this.#nextRendererId, rendererId + 1);
+    }
+    if (renderer.rendererPackageName === "ink") {
+      this.#renderers.set(rendererId, {
+        rendererId,
+        packageName: "ink",
+        ...typeof renderer.rendererVersion === "string" ? { version: renderer.rendererVersion } : {}
+      });
+    }
+    return rendererId;
+  }
+  commit(rendererId, fiberRoot) {
+    const renderer = this.#renderers.get(rendererId);
+    if (renderer === void 0) return;
+    const containerInfo = fiberRoot.containerInfo;
+    if (!isInkRoot(containerInfo)) {
+      this.#emit({ type: "invalid-root", renderer, fiberRoot, containerInfo });
+      return;
+    }
+    this.#roots.set(fiberRoot, containerInfo);
+    this.#emit({ type: "commit", renderer, fiberRoot, root: containerInfo });
+  }
+  unmount(rendererId, fiber) {
+    const renderer = this.#renderers.get(rendererId);
+    if (renderer !== void 0) this.#emit({ type: "unmount", renderer, fiber });
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  roots() {
+    return [...this.#roots.values()];
+  }
+  hasInkRenderer() {
+    return this.#renderers.size > 0;
+  }
+  #emit(event) {
+    for (const listener of this.#listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+};
+function installReactCommitBridge(target = globalThis) {
+  const holder = target;
+  const existing = holder.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  const installed = existing?.[BRIDGE];
+  if (installed !== void 0) return installed;
+  const bridge = new ReactCommitBridge();
+  const hook = Object.create(existing ?? null);
+  Object.defineProperties(hook, {
+    supportsFiber: { value: true, enumerable: true, configurable: true },
+    inject: {
+      configurable: true,
+      value(renderer) {
+        const delegatedId = existing?.inject?.call(existing, renderer);
+        return bridge.register(renderer, delegatedId);
+      }
+    },
+    onCommitFiberRoot: {
+      configurable: true,
+      value(rendererId, root, ...rest) {
+        try {
+          existing?.onCommitFiberRoot?.call(existing, rendererId, root, ...rest);
+        } finally {
+          bridge.commit(rendererId, root);
+        }
+      }
+    },
+    onCommitFiberUnmount: {
+      configurable: true,
+      value(rendererId, fiber) {
+        try {
+          existing?.onCommitFiberUnmount?.call(existing, rendererId, fiber);
+        } finally {
+          bridge.unmount(rendererId, fiber);
+        }
+      }
+    },
+    [BRIDGE]: { value: bridge }
+  });
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(holder, "__REACT_DEVTOOLS_GLOBAL_HOOK__");
+    if (descriptor?.configurable === true && ("writable" in descriptor && descriptor.writable === false || !("writable" in descriptor) && descriptor.set === void 0)) {
+      Object.defineProperty(holder, "__REACT_DEVTOOLS_GLOBAL_HOOK__", {
+        value: hook,
+        writable: true,
+        enumerable: descriptor.enumerable ?? false,
+        configurable: true
+      });
+    } else {
+      holder.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook;
+    }
+  } catch (cause) {
+    throw new Error(
+      "Ink semantic probe unavailable: the existing React renderer instrumentation hook cannot be composed.",
+      { cause }
+    );
+  }
+  return bridge;
+}
+var bridgeLeases = /* @__PURE__ */ new WeakMap();
+function acquireReactCommitBridge(target = globalThis) {
+  const holder = target;
+  const currentRecord = bridgeLeases.get(target);
+  if (currentRecord !== void 0 && holder.__REACT_DEVTOOLS_GLOBAL_HOOK__ === currentRecord.hook) {
+    currentRecord.references += 1;
+    return leaseFor(target, currentRecord);
+  }
+  const existingBridge = holder.__REACT_DEVTOOLS_GLOBAL_HOOK__?.[BRIDGE];
+  const priorDescriptor = Object.getOwnPropertyDescriptor(holder, "__REACT_DEVTOOLS_GLOBAL_HOOK__");
+  const bridge = installReactCommitBridge(target);
+  const hook = holder.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook === void 0) {
+    throw new Error(
+      "Ink semantic probe unavailable: React renderer instrumentation hook installation disappeared."
+    );
+  }
+  if (existingBridge !== void 0) return { bridge, release() {
+  } };
+  const record = {
+    bridge,
+    hook,
+    ...priorDescriptor === void 0 ? {} : { priorDescriptor },
+    references: 1
+  };
+  bridgeLeases.set(target, record);
+  return leaseFor(target, record);
+}
+function leaseFor(target, record) {
+  let released = false;
+  return {
+    bridge: record.bridge,
+    release() {
+      if (released) return;
+      released = true;
+      record.references -= 1;
+      if (record.references > 0) return;
+      bridgeLeases.delete(target);
+      const holder = target;
+      if (holder.__REACT_DEVTOOLS_GLOBAL_HOOK__ !== record.hook) return;
+      if (record.priorDescriptor === void 0) {
+        delete holder.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      } else {
+        Object.defineProperty(holder, "__REACT_DEVTOOLS_GLOBAL_HOOK__", record.priorDescriptor);
+      }
+    }
+  };
+}
+var activatedReconcilers = /* @__PURE__ */ new WeakMap();
+function activateInkRendererObservation(reconciler, target = globalThis) {
+  const bridge = installReactCommitBridge(target);
+  let bridges = activatedReconcilers.get(reconciler);
+  if (bridges === void 0) {
+    bridges = /* @__PURE__ */ new WeakSet();
+    activatedReconcilers.set(reconciler, bridges);
+  }
+  if (!bridges.has(bridge)) {
+    reconciler.injectIntoDevTools();
+    if (!bridge.hasInkRenderer())
+      throw new Error(
+        "Ink semantic probe unavailable: React renderer instrumentation did not register Ink."
+      );
+    bridges.add(bridge);
+  }
+  return bridge;
+}
+function requireCommittedInkRoot(event) {
+  if (event.type !== "commit") {
+    throw new Error(
+      "Ink semantic probe unavailable: React renderer instrumentation did not expose expected committed Ink root."
+    );
+  }
+  return event.root;
+}
+function isInkRoot(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return candidate.nodeName === "ink-root" && Array.isArray(candidate.childNodes);
+}
+
+// src/annotations.ts
+import { validateProbeAnnotations } from "@termwright/protocol";
+var REGISTRY = /* @__PURE__ */ Symbol.for("termwright.annotation.ink.v1");
+function channel() {
+  const scope = globalThis;
+  const present = scope[REGISTRY];
+  if (present?.entries instanceof WeakMap && present.listeners instanceof Set) {
+    return present;
+  }
+  const created = {
+    entries: /* @__PURE__ */ new WeakMap(),
+    listeners: /* @__PURE__ */ new Set()
+  };
+  Object.defineProperty(scope, REGISTRY, { configurable: true, value: created });
+  return created;
+}
+function onInkAnnotationChange(handler) {
+  const listeners = channel().listeners;
+  listeners.add(handler);
+  return () => listeners.delete(handler);
+}
+function strings(refs, idFor, maxTargets) {
+  if (refs === void 0) return void 0;
+  if (!Array.isArray(refs)) return null;
+  const length = Object.getOwnPropertyDescriptor(refs, "length")?.value;
+  if (!Number.isSafeInteger(length) || length < 0 || length > maxTargets) return null;
+  const ids = [];
+  for (let index = 0; index < length; index += 1) {
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(refs, String(index));
+      if (descriptor === void 0 || !("value" in descriptor)) return null;
+      const ref = descriptor.value;
+      if (!(ref instanceof WeakRef)) return null;
+      const target = WeakRef.prototype.deref.call(ref);
+      if (target !== void 0) ids.push(idFor(target));
+    } catch {
+      return null;
+    }
+  }
+  return ids.length === 0 ? void 0 : ids;
+}
+function ownData(value, key) {
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  return descriptor !== void 0 && "value" in descriptor ? descriptor.value : void 0;
+}
+function annotationForInkNode(node, idFor, limits) {
+  try {
+    const slot = channel().entries.get(node);
+    const value = slot?.current;
+    if (value === void 0) return void 0;
+    const role = ownData(value, "role");
+    const name = ownData(value, "name");
+    const description = ownData(value, "description");
+    const testId = ownData(value, "testId");
+    const extended = ownData(value, "extended");
+    const actions = ownData(value, "actions");
+    const labelledBy = strings(ownData(value, "labelledBy"), idFor, limits.maxRelationTargets);
+    const describedBy = strings(ownData(value, "describedBy"), idFor, limits.maxRelationTargets);
+    const candidate = {
+      ...role === void 0 ? {} : { role },
+      ...name === void 0 ? {} : { name },
+      ...description === void 0 ? {} : { description },
+      ...testId === void 0 ? {} : { testId },
+      ...extended === void 0 ? {} : { extended },
+      ...actions === void 0 ? {} : { actions },
+      ...labelledBy === void 0 ? {} : { labelledBy },
+      ...describedBy === void 0 ? {} : { describedBy }
+    };
+    if (Object.keys(candidate).length === 0) return void 0;
+    const validated = validateProbeAnnotations(candidate, limits);
+    return validated.ok ? validated.annotations : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/observe.ts
+var isElement = (node) => node.nodeName !== "#text";
+function observeInkTree(root, options) {
+  const objects = [];
+  const ids = identityStore(root);
+  let truncated = false;
+  const geometryRegions = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (node, parent, depth, ancestorHidden) => {
+    if (node === options.excluded || visited.has(node)) return;
+    visited.add(node);
+    if (depth > options.limits.maxDepth || objects.length >= options.limits.maxNodes) {
+      truncated = true;
+      return;
+    }
+    const hidden = ancestorHidden || node.style?.display === "none";
+    const state = observedState(node, !hidden);
+    const annotations = annotationForInkNode(
+      node,
+      (target) => ids.idFor(target),
+      options.limits
+    );
+    const accessibility = observedAccessibility(node);
+    const geometry = geometryOf(node, options);
+    const identity = ids.idFor(node);
+    const region = options.geometry?.get(node)?.region;
+    if (region !== void 0) geometryRegions.set(identity, region);
+    const children = options.retainedChildren?.get(node) ?? node.childNodes;
+    const text = isTextHost(node) ? textOf(children, options.limits.maxStringBytes) : void 0;
+    const unobservable = unobservableFor(
+      node,
+      geometry?.intendedRect !== void 0,
+      text !== void 0
+    );
+    objects.push({
+      identity: { kind: "stable", value: identity },
+      frameworkType: node.nodeName,
+      ...parent === void 0 ? {} : { parent: ids.idFor(parent) },
+      ...geometry === void 0 ? {} : { geometry },
+      ...state === void 0 ? {} : { state },
+      ...text === void 0 ? {} : { text },
+      ...accessibility === void 0 ? {} : { accessibility },
+      ...annotations === void 0 ? {} : { annotations },
+      unobservable
+    });
+    for (const child of children) {
+      if (isElement(child)) visit(child, node, depth + 1, hidden);
+    }
+  };
+  visit(root, void 0, 0, false);
+  if (root.staticNode !== void 0) visit(root.staticNode, root, 1, false);
+  for (const retained of options.retainedRoots ?? []) visit(retained, root, 1, false);
+  return { frame: { frame: options.frame, objects }, truncated, geometryRegions };
+}
+var stores = /* @__PURE__ */ new WeakMap();
+function identityStore(root) {
+  let store = stores.get(root);
+  if (store !== void 0) return store;
+  const ids = /* @__PURE__ */ new WeakMap();
+  let nextId = 0;
+  store = {
+    idFor(node) {
+      const existing = ids.get(node);
+      if (existing !== void 0) return existing;
+      nextId += 1;
+      const id = String(nextId);
+      ids.set(node, id);
+      return id;
+    }
+  };
+  stores.set(root, store);
+  return store;
+}
+function isTextHost(node) {
+  return node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text";
+}
+function observedAccessibility(node) {
+  const role = node.internal_accessibility?.role;
+  return role === void 0 ? void 0 : { role };
+}
+function observedState(node, displayed) {
+  const accessibility = node.internal_accessibility?.state;
+  const state = {
+    displayed,
+    ...accessibility?.checked === void 0 ? {} : { checked: accessibility.checked },
+    ...accessibility?.disabled === void 0 ? {} : { disabled: accessibility.disabled },
+    ...accessibility?.expanded === void 0 ? {} : { expanded: accessibility.expanded },
+    ...accessibility?.readonly === void 0 ? {} : { readonly: accessibility.readonly },
+    ...accessibility?.selected === void 0 ? {} : { selected: accessibility.selected },
+    ...accessibility?.busy === void 0 ? {} : { busy: accessibility.busy },
+    ...accessibility?.multiline === void 0 ? {} : { multiline: accessibility.multiline },
+    ...accessibility?.required === void 0 ? {} : { required: accessibility.required },
+    ...accessibility?.multiselectable === void 0 ? {} : { multiselectable: accessibility.multiselectable }
+  };
+  return state;
+}
+function geometryOf(node, options) {
+  const geometry = options.geometry?.get(node);
+  return geometry === void 0 ? void 0 : { intendedRect: geometry.intended, visibleRect: geometry.visible };
+}
+function textOf(children, maxBytes) {
+  const parts = [];
+  let bytes = 0;
+  const append = (value) => {
+    for (const codePoint of value) {
+      const size = Buffer.byteLength(codePoint, "utf8");
+      if (bytes + size > maxBytes) return;
+      parts.push(codePoint);
+      bytes += size;
+    }
+  };
+  for (const child of children) {
+    if (bytes >= maxBytes) break;
+    if (!isElement(child)) append(child.nodeValue);
+  }
+  const text = parts.join("").replace(/\s+/gu, " ").trim();
+  return text.length === 0 ? void 0 : text;
+}
+function unobservableFor(node, hasGeometry, hasText) {
+  const result = [
+    "focused",
+    "value",
+    "selectedIndex",
+    "textSelection",
+    "scroll",
+    "scrollExtent",
+    "paintOrder"
+  ];
+  const state = node.internal_accessibility?.state;
+  if (state?.disabled === void 0) result.push("disabled");
+  if (state?.checked === void 0) result.push("checked");
+  if (state?.expanded === void 0) result.push("expanded");
+  if (state?.readonly === void 0) result.push("readonly");
+  if (state?.selected === void 0) result.push("selected");
+  if (state?.busy === void 0) result.push("busy");
+  if (state?.multiline === void 0) result.push("multiline");
+  if (!hasGeometry) result.push("intendedRect", "visibleRect");
+  if (!hasText && isTextHost(node)) result.push("text");
+  return result;
+}
+
+// src/version.ts
+var PACKAGE_VERSION = "0.3.1";
+
+// src/probe-info.ts
+function probeInfo(frameworkVersion = instrumentationSentinel()?.frameworkVersion ?? INK_VERSION) {
+  return {
+    framework: "ink",
+    frameworkVersion,
+    probeVersion: PACKAGE_VERSION,
+    identityKind: "stable",
+    capabilities: ["stable-identity", "intended-rect", "visible-rect", "annotations"],
+    instrumentation: {
+      highestTier: "T3",
+      semanticClass: "A",
+      degradedCapabilities: []
+    }
+  };
+}
+
+// src/session.ts
+import { writeWindowsConsoleMarker } from "@termwright/pty";
+import { recognize } from "@termwright/recognizers";
+function createInkSession(options) {
+  let revision = 0;
+  let frames = 0;
+  let latestFrame = 0;
+  let stopped = false;
+  let queue = Promise.resolve();
+  const publicationWaiters = [];
+  const fail = (error) => {
+    if (stopped) return;
+    stopped = true;
+    const failure = error instanceof Error ? error : new Error(String(error));
+    for (const waiter of publicationWaiters.splice(0)) waiter.reject(failure);
+    options.onGuaranteeViolation?.(failure);
+    options.channel.close();
+  };
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    const failure = new Error("Ink probe stopped");
+    for (const waiter of publicationWaiters.splice(0)) waiter.reject(failure);
+    options.channel.close();
+  };
+  const resolvePublications = (frame, publishedRevision) => {
+    for (let index = publicationWaiters.length - 1; index >= 0; index -= 1) {
+      const waiter = publicationWaiters[index];
+      if (waiter === void 0 || waiter.targetFrame > frame) continue;
+      publicationWaiters.splice(index, 1);
+      waiter.resolve(publishedRevision);
+    }
+  };
+  const publish = async (frozen) => {
+    await nextMacrotask();
+    await options.waitForRenderFlush();
+    await options.tracker.drain();
+    if (stopped) return null;
+    if (!options.channel.isOpen) {
+      fail(new Error("Ink semantic channel closed before publication"));
+      return null;
+    }
+    if (frozen.number !== latestFrame) {
+      options.channel.recordCoalescedEvent();
+      return null;
+    }
+    const context = frozen.capture.context;
+    if (context === void 0) throw new Error("certified Ink frame context is unavailable");
+    if (frozen.capture.screenReader) {
+      throw new Error("Ink screen-reader output has no authoritative per-node cell geometry");
+    }
+    const position = options.tracker.position();
+    if ((context.alternateScreen ? "alternate" : "normal") !== position.buffer) {
+      throw new Error("Ink render mode and committed VT buffer disagree");
+    }
+    const columns = options.stdout.columns ?? 80;
+    const rows = options.stdout.rows ?? 24;
+    const qualified = qualifyFrame(frozen, position, columns, rows);
+    revision += 1;
+    const snapshot = recognize(qualified, {
+      sessionId: options.channel.session.sessionId,
+      revision,
+      columns,
+      rows,
+      framework: "ink",
+      paintOrderKnown: false,
+      maxStringBytes: options.channel.session.limits.maxStringBytes
+    });
+    const marker = options.channel.publish(snapshot, {
+      probeEvents: qualified.objects.length + (qualified.operations?.length ?? 0)
+    });
+    if (marker === void 0) throw new Error("Ink semantic publication was refused");
+    await options.writeMarker(marker);
+    resolvePublications(frozen.number, revision);
+    return revision;
+  };
+  return {
+    get revision() {
+      return revision;
+    },
+    get frames() {
+      return frames;
+    },
+    notifyRender(notifyOptions = {}) {
+      if (stopped) return Promise.resolve(null);
+      try {
+        const root = options.resolveRoot();
+        if (root === null) throw new Error("Ink committed frame has no retained root");
+        const capture = options.resolveCapture(root);
+        if (capture === void 0 || capture.root !== root) {
+          throw new Error("Ink committed frame has no matching certified renderer capture");
+        }
+        const excluded = options.resolveExcluded?.();
+        const observation = observeInkTree(root, {
+          frame: frames,
+          limits: options.channel.session.limits,
+          ...excluded === void 0 ? {} : { excluded },
+          ...capture.staticRoots.length === 0 ? {} : { retainedRoots: capture.staticRoots },
+          ...capture.staticChildren.size === 0 ? {} : { retainedChildren: capture.staticChildren },
+          geometry: capture.geometry
+        });
+        if (hasDisplayedNodeWithoutGeometry(observation.frame)) {
+          if (notifyOptions.allowUnsettled === true) return Promise.resolve(null);
+          throw new Error(
+            "certified Ink renderer capture is missing geometry for a displayed host node"
+          );
+        }
+        frames += 1;
+        latestFrame = frames;
+        const frozen = { number: frames, capture, observation };
+        const boundary = notifyOptions.awaitPublication === true ? new Promise((resolve, reject) => {
+          publicationWaiters.push({ targetFrame: frozen.number, resolve, reject });
+        }) : null;
+        const publication = queue.then(() => publish(frozen)).catch((error) => {
+          fail(error);
+          return null;
+        });
+        queue = publication.then(() => void 0);
+        return boundary ?? publication;
+      } catch (error) {
+        fail(error);
+        return Promise.resolve(null);
+      }
+    },
+    async flush() {
+      await queue.catch(() => void 0);
+    },
+    stop
+  };
+}
+function hasDisplayedNodeWithoutGeometry(frame) {
+  return frame.objects.some(
+    (object) => object.state?.displayed !== false && object.geometry?.intendedRect === void 0
+  );
+}
+function qualifyFrame(frozen, position, columns, rows) {
+  const { capture, observation } = frozen;
+  const context = capture.context;
+  const fullscreen = context.stdoutIsTTY && capture.liveRows >= context.rows;
+  const liveOrigin = context.alternateScreen ? 0 : !context.interactive ? position.row : context.debug || fullscreen ? position.row - Math.max(0, capture.liveRows - 1) : position.row - capture.liveRows;
+  const staticOrigin = liveOrigin - capture.staticRows;
+  return {
+    ...observation.frame,
+    objects: observation.frame.objects.map((object) => {
+      const region = observation.geometryRegions.get(object.identity.value);
+      const geometry = object.geometry;
+      if (geometry?.intendedRect === void 0 || geometry.visibleRect === void 0 || region === void 0)
+        return object;
+      const origin = region === "live" ? liveOrigin : staticOrigin;
+      const intendedRect = shift(geometry.intendedRect, origin);
+      const visibleRect = context.interactive || region === "static" || context.debug ? viewportIntersection(shift(geometry.visibleRect, origin), columns, rows) : { row: Math.min(Math.max(origin, 0), rows), column: 0, width: 0, height: 0 };
+      return { ...object, geometry: { intendedRect, visibleRect } };
+    })
+  };
+}
+function shift(rect, rows) {
+  return { ...rect, row: rect.row + rows };
+}
+function viewportIntersection(rect, columns, rows) {
+  const column = Math.max(0, rect.column);
+  const row = Math.max(0, rect.row);
+  const right = Math.max(column, Math.min(columns, rect.column + rect.width));
+  const bottom = Math.max(row, Math.min(rows, rect.row + rect.height));
+  return { row, column, width: right - column, height: bottom - row };
+}
+function nextMacrotask() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+function createInkMarkerWriter(stream, options) {
+  const platform = options.platform ?? process.platform;
+  if (!options.certifiedHarness && platform === "win32" && stream.isTTY === true) {
+    const fd = stream.fd;
+    if (typeof fd !== "number" || !Number.isInteger(fd) || fd < 0) {
+      return () => Promise.reject(new Error("Ink stdout has no certifiable Windows console handle"));
+    }
+    const writeNative = options.writeWindowsMarker ?? writeWindowsConsoleMarker;
+    return (marker) => {
+      try {
+        writeNative(fd, marker);
+        return Promise.resolve();
+      } catch (error) {
+        return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+  }
+  return (marker) => new Promise((resolve, reject) => {
+    if (stream.writableEnded || stream.destroyed) {
+      reject(new Error("Ink stdout closed before the semantic render marker could be written"));
+      return;
+    }
+    try {
+      stream.write(marker, (error) => {
+        if (error instanceof Error) reject(error);
+        else resolve();
+      });
+    } catch (error) {
+      reject(error instanceof Error ? error : new Error(String(error)));
+    }
+  });
+}
+
+export {
+  ReactCommitBridge,
+  installReactCommitBridge,
+  acquireReactCommitBridge,
+  activateInkRendererObservation,
+  requireCommittedInkRoot,
+  onInkAnnotationChange,
+  observeInkTree,
+  PACKAGE_VERSION,
+  probeInfo,
+  createInkSession,
+  createInkMarkerWriter
+};
+//# sourceMappingURL=chunk-Q75BSILO.js.map