@termwright/probe-ink 0.2.0 → 0.3.0

package/dist/instrument.js

@@ -1,115 +1,637 @@
 import {
   PACKAGE_VERSION,
-  canPublishInkGeometry,
+  acquireReactCommitBridge,
+  activateInkRendererObservation,
+  createInkMarkerWriter,
   createInkSession,
   onInkAnnotationChange,
   probeInfo
-} from "./chunk-Y5WYMWRU.js";
+} from "./chunk-5ZU7V4OQ.js";
 import {
   isInstrumented
-} from "./chunk-LO7YF74P.js";
+} from "./chunk-67M2GX5S.js";
+import {
+  INK_FRAME_CONTEXT,
+  INK_RENDER_CAPTURE,
+  instrumentationSentinel
+} from "./chunk-SLKX554P.js";
 
 // src/instrument.ts
 import { Stream } from "stream";
 import { createElement, Fragment } from "react";
-import { ENV_ENDPOINT, ENV_PROTOCOL, ENV_TOKEN, PROTOCOL_V2_ID } from "@termwright/protocol";
+import { ENV_ENDPOINT, ENV_TOKEN } from "@termwright/protocol";
 import { connectProbe } from "@termwright/probe-runtime";
+
+// src/frame-capture.ts
+var latest = /* @__PURE__ */ new WeakMap();
+function installInkCaptureHook() {
+  const globals = globalThis;
+  const previous = globals[INK_RENDER_CAPTURE];
+  const previousContext = globals[INK_FRAME_CONTEXT];
+  const hook = (root, rendered, screenReader) => {
+    if (screenReader) {
+      retainInkFrame({
+        root,
+        staticRoots: root.staticNode === void 0 ? [] : [root.staticNode],
+        staticChildren: snapshotStaticChildren(root.staticNode),
+        rendered,
+        screenReader,
+        geometry: /* @__PURE__ */ new Map(),
+        liveRows: visibleRows(rendered.output),
+        staticRows: visibleRows(rendered.staticOutput)
+      });
+      return;
+    }
+    retainInkFrame(captureInkLayout(root, rendered));
+  };
+  globals[INK_RENDER_CAPTURE] = hook;
+  const contextHook = (root, context) => {
+    const frame = latest.get(root);
+    if (frame !== void 0) latest.set(root, { ...frame, context });
+  };
+  globals[INK_FRAME_CONTEXT] = contextHook;
+  return () => {
+    if (globals[INK_RENDER_CAPTURE] === hook) {
+      if (previous === void 0) delete globals[INK_RENDER_CAPTURE];
+      else globals[INK_RENDER_CAPTURE] = previous;
+    }
+    if (globals[INK_FRAME_CONTEXT] === contextHook) {
+      if (previousContext === void 0) delete globals[INK_FRAME_CONTEXT];
+      else globals[INK_FRAME_CONTEXT] = previousContext;
+    }
+  };
+}
+function captureInkLayout(root, rendered, context) {
+  const inkRoot = root;
+  const geometry = /* @__PURE__ */ new Map();
+  const width = integer(inkRoot.yogaNode?.getComputedWidth());
+  const height = integer(inkRoot.yogaNode?.getComputedHeight());
+  walk(inkRoot, "live", 0, 0, rect(0, 0, width, height), geometry, true);
+  if (inkRoot.staticNode !== void 0) {
+    const staticRoot = inkRoot.staticNode;
+    walk(
+      staticRoot,
+      "static",
+      0,
+      0,
+      rect(
+        0,
+        0,
+        integer(staticRoot.yogaNode?.getComputedWidth()),
+        integer(staticRoot.yogaNode?.getComputedHeight())
+      ),
+      geometry,
+      false
+    );
+  }
+  return {
+    root: inkRoot,
+    staticRoots: inkRoot.staticNode === void 0 ? [] : [inkRoot.staticNode],
+    staticChildren: snapshotStaticChildren(inkRoot.staticNode),
+    rendered,
+    screenReader: false,
+    geometry,
+    liveRows: visibleRows(rendered.output),
+    staticRows: visibleRows(rendered.staticOutput),
+    ...context === void 0 ? {} : { context }
+  };
+}
+function capturedInkFrame(root) {
+  return latest.get(root);
+}
+function retainInkFrame(capture) {
+  const previous = latest.get(capture.root);
+  if (previous === void 0 || capture.screenReader) {
+    latest.set(capture.root, capture);
+    return;
+  }
+  const previousRoots = new Set(previous.staticRoots);
+  const addedRoots = capture.staticRoots.filter((root) => !previousRoots.has(root));
+  const newStaticNodes = new Set(
+    [...capture.staticChildren.keys()].filter((node) => !previous.staticChildren.has(node))
+  );
+  const hasNewStaticOutput = capture.staticRows > 0 && newStaticNodes.size > 0;
+  if (!hasNewStaticOutput) {
+    const retainedGeometry = new Map(capture.geometry);
+    for (const [node, geometry2] of previous.geometry) {
+      if (geometry2.region === "static") retainedGeometry.set(node, geometry2);
+    }
+    latest.set(capture.root, {
+      ...capture,
+      staticRoots: previous.staticRoots,
+      staticChildren: previous.staticChildren,
+      staticRows: previous.staticRows,
+      geometry: retainedGeometry
+    });
+    return;
+  }
+  const geometry = new Map(capture.geometry);
+  for (const [node, retained] of previous.geometry) {
+    if (retained.region === "static") geometry.set(node, retained);
+  }
+  for (const [node, current] of capture.geometry) {
+    if (current.region === "static") {
+      if (newStaticNodes.has(node)) {
+        geometry.set(node, {
+          ...current,
+          intended: shiftRows(current.intended, previous.staticRows),
+          visible: shiftRows(current.visible, previous.staticRows)
+        });
+      } else if (capture.staticRoots.includes(node)) {
+        const retained = previous.geometry.get(node);
+        if (retained !== void 0) {
+          geometry.set(node, {
+            ...retained,
+            intended: { ...retained.intended, height: previous.staticRows + capture.staticRows },
+            visible: { ...retained.visible, height: previous.staticRows + capture.staticRows }
+          });
+        }
+      }
+    }
+  }
+  const staticChildren = new Map(previous.staticChildren);
+  for (const [parent, currentChildren] of capture.staticChildren) {
+    const retained = staticChildren.get(parent) ?? [];
+    staticChildren.set(parent, [
+      ...retained,
+      ...currentChildren.filter((child) => !retained.includes(child))
+    ]);
+  }
+  latest.set(capture.root, {
+    ...capture,
+    staticRoots: [...previous.staticRoots, ...addedRoots],
+    staticChildren,
+    staticRows: previous.staticRows + capture.staticRows,
+    geometry
+  });
+}
+function snapshotStaticChildren(root) {
+  const result = /* @__PURE__ */ new Map();
+  if (root === void 0) return result;
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    const children = [...node.childNodes];
+    result.set(node, children);
+    for (const child of children) if (child.nodeName !== "#text") stack.push(child);
+  }
+  return result;
+}
+function shiftRows(value, rows) {
+  return { ...value, row: value.row + rows };
+}
+function walk(node, region, offsetX, offsetY, ancestorClip, output, skipStatic) {
+  if (skipStatic && node.internal_static === true) return;
+  const yoga = node.yogaNode;
+  if (yoga === void 0 || yoga.getDisplay() === 1) return;
+  const x = offsetX + integer(yoga.getComputedLeft());
+  const y = offsetY + integer(yoga.getComputedTop());
+  const intended = rect(x, y, integer(yoga.getComputedWidth()), integer(yoga.getComputedHeight()));
+  const visible = intersection(intended, ancestorClip);
+  output.set(node, { intended, visible, region });
+  let childClip = ancestorClip;
+  if (node.nodeName === "ink-box") {
+    const horizontal = node.style?.overflowX === "hidden" || node.style?.overflow === "hidden";
+    const vertical = node.style?.overflowY === "hidden" || node.style?.overflow === "hidden";
+    if (horizontal || vertical) {
+      const left = horizontal ? x + integer(yoga.getComputedBorder(0)) : ancestorClip.column;
+      const right = horizontal ? x + intended.width - integer(yoga.getComputedBorder(2)) : ancestorClip.column + ancestorClip.width;
+      const top = vertical ? y + integer(yoga.getComputedBorder(1)) : ancestorClip.row;
+      const bottom = vertical ? y + intended.height - integer(yoga.getComputedBorder(3)) : ancestorClip.row + ancestorClip.height;
+      childClip = intersection(ancestorClip, rect(left, top, right - left, bottom - top));
+    }
+  }
+  for (const child of node.childNodes) {
+    if (child.nodeName !== "#text") {
+      walk(child, region, x, y, childClip, output, skipStatic);
+    }
+  }
+}
+function integer(value) {
+  return Number.isFinite(value) ? Math.trunc(value) : 0;
+}
+function rect(column, row, width, height) {
+  return {
+    row,
+    column,
+    width: Math.max(0, width),
+    height: Math.max(0, height)
+  };
+}
+function intersection(a, b) {
+  const column = Math.max(a.column, b.column);
+  const row = Math.max(a.row, b.row);
+  const right = Math.max(column, Math.min(a.column + a.width, b.column + b.width));
+  const bottom = Math.max(row, Math.min(a.row + a.height, b.row + b.height));
+  return rect(column, row, right - column, bottom - row);
+}
+function visibleRows(output) {
+  if (output === "") return 0;
+  const lines = output.split("\n");
+  return output.endsWith("\n") ? lines.length - 1 : lines.length;
+}
+
+// src/terminal-tracker.ts
+import { createTerminal } from "@termwright/vt";
+var ShadowWriteQueue = class {
+  #queue = Promise.resolve();
+  #failure;
+  enqueue(operation) {
+    this.#queue = this.#queue.then(async () => {
+      if (this.#failure !== void 0) return;
+      try {
+        await operation();
+      } catch (error) {
+        this.#failure = error instanceof Error ? error : new Error(String(error));
+      }
+    });
+  }
+  async drain() {
+    await this.#queue;
+    if (this.#failure !== void 0) throw this.#failure;
+  }
+};
+function trackTerminal(stdout, stderr) {
+  const built = createTerminal({
+    columns: positive(stdout.columns, 80),
+    rows: positive(stdout.rows, 24),
+    scrollback: 1e5
+  });
+  const terminal = built.terminal;
+  const queue = new ShadowWriteQueue();
+  let stopped = false;
+  const restorers = [];
+  const observe = (chunk, encoding) => {
+    if (stopped) return;
+    const bytes = Buffer.isBuffer(chunk) || chunk instanceof Uint8Array ? chunk : Buffer.from(
+      String(chunk),
+      typeof encoding === "string" ? encoding : "utf8"
+    );
+    const committed = stdout.isTTY ? withOnlcr(bytes) : bytes;
+    queue.enqueue(() => writeTerminal(terminal, committed));
+  };
+  for (const stream of /* @__PURE__ */ new Set([stdout, stderr])) restorers.push(intercept(stream, observe));
+  const onResize = () => terminal.resize(positive(stdout.columns, terminal.cols), positive(stdout.rows, terminal.rows));
+  stdout.on("resize", onResize);
+  restorers.push(() => stdout.off("resize", onResize));
+  return {
+    drain: () => queue.drain(),
+    position() {
+      const buffer = terminal.buffer.active;
+      return { row: buffer.cursorY, column: buffer.cursorX, buffer: buffer.type };
+    },
+    resize(columns, rows) {
+      terminal.resize(columns, rows);
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      for (const restore of restorers.reverse()) restore();
+      terminal.dispose();
+    }
+  };
+}
+function withOnlcr(bytes) {
+  let newlines = 0;
+  for (const byte of bytes) if (byte === 10) newlines += 1;
+  if (newlines === 0) return bytes;
+  const output = new Uint8Array(bytes.length + newlines);
+  let index = 0;
+  for (const byte of bytes) {
+    if (byte === 10) output[index++] = 13;
+    output[index++] = byte;
+  }
+  return output;
+}
+function intercept(stream, observe) {
+  const target = stream;
+  const original = target.write;
+  const wrapped = function(...args) {
+    observe(args[0], args[1]);
+    return Reflect.apply(original, this, args);
+  };
+  try {
+    target.write = wrapped;
+  } catch (error) {
+    throw new Error("Ink terminal stream cannot be instrumented exactly", { cause: error });
+  }
+  return () => {
+    if (target.write === wrapped) target.write = original;
+  };
+}
+function writeTerminal(terminal, bytes) {
+  return new Promise((resolve) => terminal.write(bytes, resolve));
+}
+function positive(value, fallback) {
+  return Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+
+// src/render-boundary.ts
+var RenderBoundaryQueue = class {
+  #pending = [];
+  #preparing = /* @__PURE__ */ new Set();
+  #nextGeneration = 1;
+  #stopped = false;
+  take(committedGeneration) {
+    const boundary = this.#pending[0];
+    if (boundary === void 0 || boundary.generation !== committedGeneration) return void 0;
+    return this.#pending.shift();
+  }
+  afterCurrentRender(waitForCurrentRender, mutate) {
+    if (this.#stopped) return Promise.reject(stoppedError());
+    return new Promise((resolve, reject) => {
+      const boundary = { generation: this.#nextGeneration, resolve, reject };
+      this.#nextGeneration += 1;
+      this.#preparing.add(boundary);
+      let flush;
+      try {
+        flush = waitForCurrentRender();
+      } catch (error) {
+        this.#preparing.delete(boundary);
+        reject(asError(error));
+        return;
+      }
+      void flush.then(
+        () => {
+          this.#preparing.delete(boundary);
+          if (this.#stopped) return;
+          this.#pending.push(boundary);
+          try {
+            mutate(boundary.generation);
+          } catch (error) {
+            const index = this.#pending.indexOf(boundary);
+            if (index !== -1) this.#pending.splice(index, 1);
+            reject(asError(error));
+          }
+        },
+        (error) => {
+          this.#preparing.delete(boundary);
+          reject(asError(error));
+        }
+      );
+    });
+  }
+  stop() {
+    if (this.#stopped) return;
+    this.#stopped = true;
+    for (const boundary of this.#preparing) boundary.reject(stoppedError());
+    for (const boundary of this.#pending.splice(0)) {
+      boundary.reject(stoppedError());
+    }
+  }
+};
+function stoppedError() {
+  return new Error("Ink probe stopped before the render boundary");
+}
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/instrument.ts
+var processTracker = trackTerminal(process.stdout, process.stderr);
 var ADAPTER_NAME = "@termwright/probe-ink";
 var ADAPTER_VERSION = PACKAGE_VERSION;
+var INK_CAPABILITIES = [
+  "tree",
+  "intended-geometry",
+  "clipped-geometry",
+  "states",
+  "actions",
+  "render-revisions"
+];
+var INK_FLUSH_NEXT_RENDER = /* @__PURE__ */ Symbol.for("@termwright/probe-ink/flush-next-render");
+var COMMIT_GENERATION_ATTRIBUTE = "__termwrightCommitGeneration";
 function wrapInkRender(ink, options = {}) {
   const env = options.env ?? process.env;
   const wrapped = (node, suppliedOptions) => {
     if (!isInstrumented(env)) return ink.render(node, suppliedOptions);
-    try {
-      return instrumentedRender(ink, node, suppliedOptions, env);
-    } catch {
-      return ink.render(node, suppliedOptions);
-    }
+    return instrumentedRender(
+      ink,
+      node,
+      suppliedOptions,
+      env,
+      options.certifiedHarness === true,
+      options.reconciler,
+      options.connect ?? connectProbe
+    );
   };
   Object.defineProperty(wrapped, "__termwright__", { value: true });
   return wrapped;
 }
-function instrumentedRender(ink, node, suppliedOptions, env) {
-  const options = normalizeOptions(suppliedOptions);
+function instrumentedRender(ink, node, suppliedOptions, env, certifiedHarness, reconciler, connector) {
+  const certifiedRuntime = instrumentationSentinel() !== void 0;
+  if (!certifiedRuntime && !certifiedHarness) return ink.render(node, suppliedOptions);
+  let options;
+  try {
+    options = normalizeOptions(suppliedOptions);
+  } catch (error) {
+    return renderAfterSetupFailure(ink, node, suppliedOptions, connector, env, error);
+  }
+  let currentNode = node;
+  let commitGeneration = 0;
   const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const ownsTracker = stdout !== process.stdout || stderr !== process.stderr;
+  let tracker = processTracker;
   const probeRef = { current: null };
   const state = {
     channel: null,
     session: null
   };
   let disposed = false;
-  const releaseAnnotations = onInkAnnotationChange(() => state.session?.notifyRender());
+  const renderBoundaries = new RenderBoundaryQueue();
+  let reactRoot = null;
+  let reactBridge;
+  let releaseCapture;
+  let releaseReactBridge;
+  let releaseReactBridgeHook;
+  let releaseAnnotations;
+  const stop = () => {
+    if (disposed) return;
+    disposed = true;
+    renderBoundaries.stop();
+    releaseCapture?.();
+    releaseReactBridge?.();
+    releaseReactBridgeHook?.();
+    releaseAnnotations?.();
+    if (ownsTracker) tracker.stop();
+    state.session?.stop();
+    state.channel?.close();
+  };
+  try {
+    releaseCapture = installInkCaptureHook();
+    tracker = ownsTracker ? trackTerminal(stdout, stderr) : processTracker;
+    if (reconciler !== void 0) {
+      const bridgeLease = acquireReactCommitBridge();
+      reactBridge = bridgeLease.bridge;
+      releaseReactBridgeHook = bridgeLease.release;
+      if (env["DEV"] !== "true") {
+        reactBridge = activateInkRendererObservation(reconciler);
+      }
+      releaseReactBridge = reactBridge.subscribe((event) => {
+        if (event.type === "commit" && probeRef.current?.parentNode === event.root) {
+          reactRoot = event.root;
+        }
+      });
+    }
+    releaseAnnotations = onInkAnnotationChange(() => {
+      setImmediate(() => {
+        if (!disposed) state.session?.notifyRender({ allowUnsettled: true });
+      });
+    });
+  } catch (error) {
+    stop();
+    return renderAfterSetupFailure(ink, node, suppliedOptions, connector, env, error);
+  }
   const wrap = (child) => createElement(
     Fragment,
     null,
-    createElement(ink.Box, { ref: probeRef, display: "none" }),
+    createElement(ink.Box, {
+      ref: probeRef,
+      display: "none",
+      [COMMIT_GENERATION_ATTRIBUTE]: commitGeneration
+    }),
     child
   );
   const userOnRender = options.onRender;
-  const instance = ink.render(wrap(node), {
-    ...options,
-    onRender(metrics) {
+  let instrumentedNode;
+  let instrumentedOptions;
+  try {
+    instrumentedNode = wrap(node);
+    instrumentedOptions = {
+      ...options,
+      onRender(metrics) {
+        const generation = probeRef.current?.style?.[COMMIT_GENERATION_ATTRIBUTE];
+        const boundary = typeof generation === "number" ? renderBoundaries.take(generation) : void 0;
+        try {
+          if (!certifiedRuntime) {
+            const root = probeRef.current?.parentNode ?? null;
+            if (root !== null) {
+              const measured = ink.measureElement(root);
+              const staticNode = root.staticNode;
+              const staticRows = staticNode === void 0 ? 0 : ink.measureElement(staticNode).height;
+              retainInkFrame(
+                captureInkLayout(
+                  root,
+                  {
+                    output: "",
+                    outputHeight: measured.height,
+                    staticOutput: "\n".repeat(staticRows)
+                  },
+                  {
+                    interactive: options.interactive === true,
+                    alternateScreen: options.alternateScreen === true,
+                    debug: options.debug === true,
+                    stdoutIsTTY: stdout.isTTY === true,
+                    rows: stdout.rows ?? 24
+                  }
+                )
+              );
+            }
+          }
+          const publication = state.session?.notifyRender({
+            awaitPublication: boundary !== void 0
+          });
+          if (boundary !== void 0) {
+            if (publication === void 0) {
+              boundary.reject(new Error("Ink semantic session is not attached"));
+            } else {
+              void publication.then(
+                (revision) => {
+                  if (revision === null) boundary.reject(new Error("Ink render was not published"));
+                  else boundary.resolve(revision);
+                },
+                (error) => boundary.reject(error instanceof Error ? error : new Error(String(error)))
+              );
+            }
+          }
+        } catch (error) {
+          boundary?.reject(error instanceof Error ? error : new Error(String(error)));
+          state.session?.stop();
+        }
+        userOnRender?.(metrics);
+      }
+    };
+  } catch (error) {
+    stop();
+    return renderAfterSetupFailure(ink, node, suppliedOptions, connector, env, error);
+  }
+  let instance;
+  try {
+    instance = ink.render(instrumentedNode, instrumentedOptions);
+  } catch (error) {
+    stop();
+    throw error;
+  }
+  if (reconciler !== void 0 && reactBridge?.hasInkRenderer() !== true) {
+    const error = new Error(
+      "Ink semantic probe unavailable: React renderer instrumentation did not register Ink."
+    );
+    stop();
+    reportSetupFailure(connector, env, error);
+    return instance;
+  }
+  let connection;
+  try {
+    connection = connector({
+      endpoint: env[ENV_ENDPOINT],
+      token: env[ENV_TOKEN],
+      probe: probeInfo(),
+      capabilities: INK_CAPABILITIES,
+      adapterName: ADAPTER_NAME,
+      adapterVersion: ADAPTER_VERSION
+    }).then(async (channel) => {
+      if (channel === null || disposed) {
+        channel?.close();
+        return;
+      }
+      state.channel = channel;
+      state.session = createInkSession({
+        channel,
+        // The React bridge observes the same committed Ink host root through
+        // FiberRoot.containerInfo. Keep the hidden ref as the certified
+        // control while differential conformance is still in progress.
+        resolveRoot: () => reactRoot ?? probeRef.current?.parentNode ?? null,
+        resolveExcluded: () => probeRef.current,
+        resolveCapture: (root) => capturedInkFrame(root),
+        waitForRenderFlush: () => instance.waitUntilRenderFlush(),
+        stdout,
+        writeMarker: createInkMarkerWriter(stdout, { certifiedHarness }),
+        tracker,
+        onGuaranteeViolation: (error) => {
+          state.session?.stop();
+          channel.fail("adapter-guarantee-violation", error.message);
+          if (channel.isOpen) channel.close();
+        }
+      });
       try {
-        state.session?.notifyRender();
+        await renderBoundaries.afterCurrentRender(
+          () => instance.waitUntilRenderFlush(),
+          (generation) => {
+            commitGeneration = generation;
+            instance.rerender(wrap(currentNode));
+          }
+        );
       } catch {
-        state.session?.stop();
+        state.session.stop();
+        return;
       }
-      userOnRender?.(metrics);
-    }
-  });
-  const includeGeometry = canPublishInkGeometry({
-    alternateScreen: options.alternateScreen === true,
-    ...options.interactive === void 0 ? {} : { interactive: options.interactive },
-    stdoutIsTTY: stdout.isTTY === true
-  });
-  const baseCapabilities = includeGeometry ? ["tree", "bounds", "absolute-bounds", "states", "actions", "render-revisions"] : ["tree", "states", "actions", "render-revisions"];
-  const qualified = env[ENV_PROTOCOL] === PROTOCOL_V2_ID;
-  const capabilities = qualified ? [...baseCapabilities, "qualified-observations"] : baseCapabilities;
-  const connection = connectProbe({
-    endpoint: env[ENV_ENDPOINT],
-    token: env[ENV_TOKEN],
-    probe: probeInfo(),
-    capabilities,
-    adapterName: ADAPTER_NAME,
-    adapterVersion: ADAPTER_VERSION,
-    ...qualified ? { protocol: PROTOCOL_V2_ID } : {}
-  }).then(async (channel) => {
-    if (channel === null || disposed) {
-      channel?.close();
-      return;
-    }
-    state.channel = channel;
-    state.session = createInkSession({
-      channel,
-      resolveRoot: () => probeRef.current?.parentNode ?? null,
-      resolveExcluded: () => probeRef.current,
-      measureElement: ink.measureElement,
-      stdout,
-      includeGeometry
-    });
-    try {
-      await instance.waitUntilRenderFlush();
-    } catch {
-      state.session.stop();
-      return;
-    }
-    if (!disposed && state.session.frames === 0) state.session.notifyRender();
-  }).catch(() => void 0);
-  const stop = () => {
-    if (disposed) return;
-    disposed = true;
-    releaseAnnotations();
-    state.session?.stop();
-    state.channel?.close();
-  };
+    }).catch(() => void 0);
+  } catch (error) {
+    stop();
+    reportSetupFailure(connector, env, error);
+    return instance;
+  }
   void instance.waitUntilExit().catch(() => void 0).then(async () => {
+    renderBoundaries.stop();
     await connection;
     await state.session?.flush();
     stop();
   }).catch(stop);
-  return {
+  const wrappedInstance = {
     ...instance,
     rerender(next) {
+      currentNode = next;
       instance.rerender(wrap(next));
     },
     unmount(error) {
@@ -118,8 +640,18 @@ function instrumentedRender(ink, node, suppliedOptions, env) {
     cleanup() {
       stop();
       instance.cleanup();
+    },
+    [INK_FLUSH_NEXT_RENDER](mutate) {
+      return renderBoundaries.afterCurrentRender(
+        () => instance.waitUntilRenderFlush(),
+        (generation) => {
+          commitGeneration = generation;
+          mutate();
+        }
+      );
     }
   };
+  return wrappedInstance;
 }
 function normalizeOptions(supplied) {
   if (supplied === void 0) return {};
@@ -128,7 +660,36 @@ function normalizeOptions(supplied) {
   }
   return supplied;
 }
+function reportSetupFailure(connector, env, failure) {
+  const error = failure instanceof Error ? failure : new Error(String(failure));
+  try {
+    void connector({
+      endpoint: env[ENV_ENDPOINT],
+      token: env[ENV_TOKEN],
+      probe: probeInfo(),
+      capabilities: INK_CAPABILITIES,
+      adapterName: ADAPTER_NAME,
+      adapterVersion: ADAPTER_VERSION
+    }).then((channel) => {
+      if (channel === null) return;
+      channel.fail("adapter-guarantee-violation", error.message);
+      if (channel.isOpen) channel.close();
+    }).catch(() => void 0);
+  } catch {
+  }
+}
+function renderAfterSetupFailure(ink, node, suppliedOptions, connector, env, setupFailure) {
+  try {
+    const instance = ink.render(node, suppliedOptions);
+    reportSetupFailure(connector, env, setupFailure);
+    return instance;
+  } catch (applicationError) {
+    reportSetupFailure(connector, env, setupFailure);
+    throw applicationError;
+  }
+}
 export {
+  INK_FLUSH_NEXT_RENDER,
   wrapInkRender
 };
 //# sourceMappingURL=instrument.js.map