@termwright/probe-ink 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 gorce-ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+# @termwright/probe-ink
+
+Zero-config semantics for an Ink 7 application that imports nothing from
+termwright. The application keeps its normal `import {render} from 'ink'` and
+normal `render(<App />)` call; the launcher adds one preload flag.
+
+## Install and launch
+
+```sh
+npm install --save-dev @termwright/probe-ink
+```
+
+Peers: `ink >= 7.1 < 8`, React >= 19.2. Node >= 22, or Bun.
+
+```ts
+import {withProbe} from '@termwright/probe-ink';
+
+const {command} = withProbe('node', ['node', 'app.mjs']);
+await launchTerminal({
+  command,
+  env: {
+    TERMWRIGHT_ENDPOINT: endpoint,
+    TERMWRIGHT_TOKEN: token,
+  },
+});
+```
+
+For Bun, pass `withProbe('bun', ['bun', 'app.tsx'])`; the launcher places
+`--preload` before the application entry, where Bun requires it. Node uses
+`--import`. The returned preload path is a `file://` URL, including on Windows.
+
+Early Node 22 releases do not have `module.registerHooks`; the preload detects
+that case and uses `module.register`. It does not change Node's warning policy.
+Pinned Ink itself emits a JSON-import ExperimentalWarning on Node 22.9, with or
+without the probe, and byte parity retains it.
+
+## Dormant and failure behaviour
+
+Without both `TERMWRIGHT_ENDPOINT` and `TERMWRIGHT_TOKEN`, the preload installs
+no loader hook and `ink.render` is untouched. If the driver is unavailable or
+the observed Ink internals move, semantics disable themselves and the
+application continues. Process tests assert byte identity for dormant and
+faulted runs under both Node and Bun.
+
+## What is observed
+
+Every retained Ink host survives into Probe IR:
+
+- `ink-root` becomes `application`;
+- `ink-text` and `ink-virtual-text` become `text`;
+- every unannotated `ink-box` remains a `generic` node with its subtree;
+- retained `aria-role` plus `checked`, `disabled`, `expanded`, `readonly`,
+  `selected`, `busy`, and `multiline` aria-state facts are read directly;
+- host object identity is kept in a `WeakMap`, so it is stable across renders.
+
+An application may optionally import `@termwright/ink` and attach developer
+intent with `useSemantic` or `<Semantic>`. The injected probe consumes that
+process-local weak registry and merges `role`, `name`, `description`, `testId`,
+domain `extended` state, actions, and relationships with the retained tree.
+Developer annotations have annotation provenance; Ink-retained ARIA hints keep
+framework provenance. Physical facts such as text, state, focus, visibility,
+value, and bounds cannot be supplied by the annotation SDK.
+
+Each live update publishes a full snapshot and revision commit. Ink calls
+`onRender` before it writes frame bytes, so the probe freezes the laid-out host
+tree synchronously, then drains the output stream and writes the authenticated
+marker last. A newer render that arrives during drain suppresses the stale
+marker. Instrumented output is byte-identical to vanilla output after those
+markers are removed.
+
+Bounds are published only when Ink runs interactively in the alternate screen
+buffer and no `<Static>` content shifts the live region. Otherwise coordinates
+are omitted rather than reported as terminal-absolute when they are not.
+With `TERMWRIGHT_PROTOCOL=termwright/2`, those facts use tagged observations:
+display is known, intended bounds are known or explicitly unsupported, and
+visible clipping plus pointer ownership are unsupported rather than inferred.
+
+## Deliberate limits
+
+Ink's reconciler discards application component names before creating the host
+tree. A source component such as `ApproveButton` therefore cannot be reported:
+`frameworkType` honestly remains `ink-box`, never a guessed component name or
+stack. The same boundary prevents attributing Ink's active focus id to a host.
+Text selection and third-party input values also remain unobservable without a
+widget-library probe or author annotation. Ink retains `required` and
+`multiselectable`, but the current semantic wire has no corresponding state
+fields, so this probe omits them rather than repurposing a different fact.
+
+Ink does not retain `aria-label` on a host element. A role that takes its name
+from content uses rendered text; containers keep an empty name. These limits are
+upstream facts documented in `docs/architecture/audit/ink.md`, not heuristics.
+
+`@termwright/ink` is only the optional annotation SDK. Rendering, observation,
+transport, and revision publication remain owned by this injected probe.

package/dist/bun-preload.d.ts

@@ -0,0 +1,5 @@
+/** Bun entry: `bun --preload @termwright/probe-ink/bun-preload app.js`. */
+/** Register the Ink entry replacement before the application's first import. */
+declare function installBunPreload(env?: Record<string, string | undefined>): boolean;
+
+export { installBunPreload };

package/dist/bun-preload.js

@@ -0,0 +1,30 @@
+import {
+  INK_ENTRY_PATTERN,
+  buildShimSource,
+  shouldShim
+} from "./chunk-IUFXTMZ7.js";
+import {
+  isInstrumented
+} from "./chunk-LO7YF74P.js";
+
+// src/bun-preload.ts
+function installBunPreload(env = process.env) {
+  if (!isInstrumented(env)) return false;
+  const bun = globalThis.Bun;
+  if (bun === void 0) return false;
+  bun.plugin({
+    name: "termwright-ink",
+    setup(build) {
+      build.onLoad({ filter: INK_ENTRY_PATTERN }, async (args) => {
+        if (!shouldShim(args.path)) return void 0;
+        return { loader: "js", contents: buildShimSource(args.path) };
+      });
+    }
+  });
+  return true;
+}
+installBunPreload();
+export {
+  installBunPreload
+};
+//# sourceMappingURL=bun-preload.js.map

package/dist/bun-preload.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bun-preload.ts"],"sourcesContent":["/** Bun entry: `bun --preload @termwright/probe-ink/bun-preload app.js`. */\n\nimport { buildShimSource, INK_ENTRY_PATTERN, shouldShim } from './shim.js';\nimport { isInstrumented } from './runtime.js';\n\ninterface BunPluginBuild {\n  onLoad(\n    options: { filter: RegExp },\n    callback: (args: { path: string }) => Promise<{ loader: string; contents: string } | undefined>,\n  ): void;\n}\n\ninterface BunGlobal {\n  plugin(definition: { name: string; setup(build: BunPluginBuild): void }): void;\n}\n\n/** Register the Ink entry replacement before the application's first import. */\nexport function installBunPreload(\n  env: Record<string, string | undefined> = process.env,\n): boolean {\n  if (!isInstrumented(env)) return false;\n  const bun = (globalThis as { Bun?: BunGlobal }).Bun;\n  if (bun === undefined) return false;\n\n  bun.plugin({\n    name: 'termwright-ink',\n    setup(build) {\n      build.onLoad({ filter: INK_ENTRY_PATTERN }, async (args) => {\n        if (!shouldShim(args.path)) return undefined;\n        return { loader: 'js', contents: buildShimSource(args.path) };\n      });\n    },\n  });\n  return true;\n}\n\ninstallBunPreload();\n"],"mappings":";;;;;;;;;;AAiBO,SAAS,kBACd,MAA0C,QAAQ,KACzC;AACT,MAAI,CAAC,eAAe,GAAG,EAAG,QAAO;AACjC,QAAM,MAAO,WAAmC;AAChD,MAAI,QAAQ,OAAW,QAAO;AAE9B,MAAI,OAAO;AAAA,IACT,MAAM;AAAA,IACN,MAAM,OAAO;AACX,YAAM,OAAO,EAAE,QAAQ,kBAAkB,GAAG,OAAO,SAAS;AAC1D,YAAI,CAAC,WAAW,KAAK,IAAI,EAAG,QAAO;AACnC,eAAO,EAAE,QAAQ,MAAM,UAAU,gBAAgB,KAAK,IAAI,EAAE;AAAA,MAC9D,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AACD,SAAO;AACT;AAEA,kBAAkB;","names":[]}

package/dist/chunk-IUFXTMZ7.js

@@ -0,0 +1,31 @@
+// src/shim.ts
+var ORIGINAL_MARKER = "termwright-original=1";
+var INK_ENTRY_PATTERN = /[\\/](?:ink|ink@[^\\/]+)[\\/]build[\\/]index\.js$/u;
+var INSTRUMENT_URL = new URL("./instrument.js", import.meta.url).href;
+function shouldShim(urlOrPath) {
+  if (urlOrPath.includes(ORIGINAL_MARKER)) return false;
+  return INK_ENTRY_PATTERN.test(urlOrPath.split("?")[0] ?? "");
+}
+function originalUrl(urlOrPath) {
+  return `${urlOrPath}${urlOrPath.includes("?") ? "&" : "?"}${ORIGINAL_MARKER}`;
+}
+function buildShimSource(target, instrumentUrl = INSTRUMENT_URL) {
+  const original = JSON.stringify(originalUrl(target));
+  const instrument = JSON.stringify(instrumentUrl);
+  return `import * as __termwright_original from ${original};
+import {wrapInkRender as __termwright_wrap} from ${instrument};
+export * from ${original};
+
+export const render = __termwright_wrap(__termwright_original);
+`;
+}
+
+export {
+  ORIGINAL_MARKER,
+  INK_ENTRY_PATTERN,
+  INSTRUMENT_URL,
+  shouldShim,
+  originalUrl,
+  buildShimSource
+};
+//# sourceMappingURL=chunk-IUFXTMZ7.js.map

package/dist/chunk-IUFXTMZ7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shim.ts"],"sourcesContent":["/** Replacement source for Ink's public entry module. */\n\n/** Marker on the shim's re-import of the untouched module. */\nexport const ORIGINAL_MARKER = 'termwright-original=1';\n\n/**\n * Ink's ESM entry under ordinary node_modules and Bun's versioned cache.\n * Matching the resolved path, rather than the bare specifier, is required by\n * both loader APIs used here.\n */\nexport const INK_ENTRY_PATTERN = /[\\\\/](?:ink|ink@[^\\\\/]+)[\\\\/]build[\\\\/]index\\.js$/u;\n\n/** The separately-built runtime imported by replacement module source. */\nexport const INSTRUMENT_URL = new URL('./instrument.js', import.meta.url).href;\n\nexport function shouldShim(urlOrPath: string): boolean {\n  if (urlOrPath.includes(ORIGINAL_MARKER)) return false;\n  return INK_ENTRY_PATTERN.test(urlOrPath.split('?')[0] ?? '');\n}\n\nexport function originalUrl(urlOrPath: string): string {\n  return `${urlOrPath}${urlOrPath.includes('?') ? '&' : '?'}${ORIGINAL_MARKER}`;\n}\n\n/**\n * Forward the complete Ink namespace and shadow only `render`.\n *\n * The wrapper receives the already-marked original namespace, so the runtime\n * never imports `ink` itself and cannot recurse through the loader hook.\n */\nexport function buildShimSource(target: string, instrumentUrl = INSTRUMENT_URL): string {\n  const original = JSON.stringify(originalUrl(target));\n  const instrument = JSON.stringify(instrumentUrl);\n  return `import * as __termwright_original from ${original};\nimport {wrapInkRender as __termwright_wrap} from ${instrument};\nexport * from ${original};\n\nexport const render = __termwright_wrap(__termwright_original);\n`;\n}\n"],"mappings":";AAGO,IAAM,kBAAkB;AAOxB,IAAM,oBAAoB;AAG1B,IAAM,iBAAiB,IAAI,IAAI,mBAAmB,YAAY,GAAG,EAAE;AAEnE,SAAS,WAAW,WAA4B;AACrD,MAAI,UAAU,SAAS,eAAe,EAAG,QAAO;AAChD,SAAO,kBAAkB,KAAK,UAAU,MAAM,GAAG,EAAE,CAAC,KAAK,EAAE;AAC7D;AAEO,SAAS,YAAY,WAA2B;AACrD,SAAO,GAAG,SAAS,GAAG,UAAU,SAAS,GAAG,IAAI,MAAM,GAAG,GAAG,eAAe;AAC7E;AAQO,SAAS,gBAAgB,QAAgB,gBAAgB,gBAAwB;AACtF,QAAM,WAAW,KAAK,UAAU,YAAY,MAAM,CAAC;AACnD,QAAM,aAAa,KAAK,UAAU,aAAa;AAC/C,SAAO,0CAA0C,QAAQ;AAAA,mDACR,UAAU;AAAA,gBAC7C,QAAQ;AAAA;AAAA;AAAA;AAIxB;","names":[]}

package/dist/chunk-LO7YF74P.js

@@ -0,0 +1,12 @@
+// src/runtime.ts
+import { ENV_ENDPOINT, ENV_TOKEN } from "@termwright/protocol";
+function isInstrumented(env) {
+  const endpoint = env[ENV_ENDPOINT];
+  const token = env[ENV_TOKEN];
+  return typeof endpoint === "string" && endpoint.length > 0 && typeof token === "string" && token.length > 0;
+}
+
+export {
+  isInstrumented
+};
+//# sourceMappingURL=chunk-LO7YF74P.js.map

package/dist/chunk-LO7YF74P.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/runtime.ts"],"sourcesContent":["/** Runtime activation shared by the two preload entry points. */\n\nimport { ENV_ENDPOINT, ENV_TOKEN } from '@termwright/protocol';\n\n/** Runtimes into which the Ink probe can be injected. */\nexport type ProbeRuntime = 'bun' | 'node';\n\n/** Read-only environment view, so activation is testable without mutation. */\nexport type EnvSource = Readonly<Record<string, string | undefined>>;\n\n/** Both secrets are required. A partial environment remains fully dormant. */\nexport function isInstrumented(env: EnvSource): boolean {\n  const endpoint = env[ENV_ENDPOINT];\n  const token = env[ENV_TOKEN];\n  return typeof endpoint === 'string' && endpoint.length > 0\n    && typeof token === 'string' && token.length > 0;\n}\n"],"mappings":";AAEA,SAAS,cAAc,iBAAiB;AASjC,SAAS,eAAe,KAAyB;AACtD,QAAM,WAAW,IAAI,YAAY;AACjC,QAAM,QAAQ,IAAI,SAAS;AAC3B,SAAO,OAAO,aAAa,YAAY,SAAS,SAAS,KACpD,OAAO,UAAU,YAAY,MAAM,SAAS;AACnD;","names":[]}

package/dist/chunk-Y5WYMWRU.js

@@ -0,0 +1,358 @@
+// 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 visit = (node, parent, depth, ancestorHidden) => {
+    if (node === options.excluded) return;
+    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 text = isTextHost(node) ? textOf(node, options.limits.maxStringBytes) : void 0;
+    const unobservable = unobservableFor(node, geometry !== void 0, text !== void 0);
+    objects.push({
+      identity: { kind: "stable", value: ids.idFor(node) },
+      frameworkType: node.nodeName,
+      ...parent === void 0 ? {} : { parent: ids.idFor(parent) },
+      ...geometry === void 0 ? {} : { geometry: { intendedRect: geometry } },
+      ...state === void 0 ? {} : { state },
+      ...text === void 0 ? {} : { text },
+      ...accessibility === void 0 ? {} : { accessibility },
+      ...annotations === void 0 ? {} : { annotations },
+      unobservable
+    });
+    for (const child of node.childNodes) {
+      if (isElement(child)) visit(child, node, depth + 1, hidden);
+    }
+  };
+  visit(root, void 0, 0, false);
+  return { frame: { frame: options.frame, objects }, truncated };
+}
+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 }
+  };
+  return state;
+}
+function geometryOf(node, options) {
+  if (options.includeGeometry !== true || options.measureElement === void 0) return void 0;
+  if (node.nodeName === "ink-virtual-text") return void 0;
+  try {
+    const measured = options.measureElement(node);
+    if (!Number.isFinite(measured.x) || !Number.isFinite(measured.y) || !Number.isFinite(measured.width) || !Number.isFinite(measured.height) || measured.width <= 0 || measured.height <= 0) return void 0;
+    return {
+      row: Math.trunc(measured.y),
+      column: Math.trunc(measured.x),
+      width: Math.trunc(measured.width),
+      height: Math.trunc(measured.height)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function textOf(node, 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 node.childNodes) {
+    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",
+    "visibleRect",
+    "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");
+  if (!hasText && isTextHost(node)) result.push("text");
+  return result;
+}
+function hasStaticContent(root) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.internal_static === true || node.staticNode !== void 0) return true;
+    for (const child of node.childNodes) if (isElement(child)) stack.push(child);
+  }
+  return false;
+}
+
+// src/geometry.ts
+function canPublishInkGeometry(options) {
+  const interactive = options.interactive ?? (!(options.inCi ?? runningInCi()) && options.stdoutIsTTY);
+  return options.alternateScreen && interactive && options.stdoutIsTTY;
+}
+function runningInCi() {
+  return enabledEnvironmentFlag("CI") || enabledEnvironmentFlag("CONTINUOUS_INTEGRATION");
+}
+function enabledEnvironmentFlag(name) {
+  const value = process.env[name];
+  return value !== void 0 && value !== "0" && value !== "false";
+}
+
+// src/version.ts
+var PACKAGE_VERSION = "0.2.0";
+
+// src/session.ts
+import { recognize } from "@termwright/recognizers";
+function probeInfo() {
+  return {
+    framework: "ink",
+    probeVersion: PACKAGE_VERSION,
+    identityKind: "stable",
+    // The optional @termwright/ink SDK writes author intent to the shared weak
+    // registry. Ink's own aria metadata travels separately as framework facts.
+    capabilities: ["stable-identity", "annotations"]
+  };
+}
+function createInkSession(options) {
+  let revision = 0;
+  let frames = 0;
+  let latestFrame = 0;
+  let staticSeen = false;
+  let stopped = false;
+  let queue = Promise.resolve();
+  const fail = () => {
+    if (stopped) return;
+    stopped = true;
+    options.channel.close();
+  };
+  const writeMarker = async (frame, marker) => {
+    await nextMacrotask();
+    if (stopped || !options.channel.isOpen) return;
+    if (frame !== latestFrame) {
+      options.channel.recordCoalescedEvent();
+      return;
+    }
+    await drain(options.stdout);
+    if (stopped || !options.channel.isOpen) return;
+    if (frame !== latestFrame) {
+      options.channel.recordCoalescedEvent();
+      return;
+    }
+    options.stdout.write(marker);
+  };
+  return {
+    get revision() {
+      return revision;
+    },
+    get frames() {
+      return frames;
+    },
+    notifyRender() {
+      if (stopped) return;
+      frames += 1;
+      const frame = frames;
+      latestFrame = frame;
+      try {
+        const root = options.resolveRoot();
+        if (root === null) return;
+        staticSeen ||= hasStaticContent(root);
+        const includeGeometry = options.includeGeometry && !staticSeen;
+        const excluded = options.resolveExcluded?.();
+        const observation = observeInkTree(root, {
+          frame,
+          limits: options.channel.session.limits,
+          ...excluded === void 0 ? {} : { excluded },
+          measureElement: options.measureElement,
+          includeGeometry
+        });
+        revision += 1;
+        const snapshot = recognize(observation.frame, {
+          sessionId: options.channel.session.sessionId,
+          revision,
+          columns: options.stdout.columns ?? 80,
+          rows: options.stdout.rows ?? 24,
+          framework: "ink",
+          paintOrderKnown: false,
+          maxStringBytes: options.channel.session.limits.maxStringBytes,
+          qualified: options.channel.session.protocol === "termwright/2"
+        });
+        const marker = options.channel.publish(snapshot, {
+          probeEvents: observation.frame.objects.length + (observation.frame.operations?.length ?? 0)
+        });
+        if (marker === void 0) return;
+        queue = queue.then(() => writeMarker(frame, marker)).catch(fail);
+      } catch {
+        fail();
+      }
+    },
+    async flush() {
+      await queue.catch(() => void 0);
+    },
+    stop() {
+      fail();
+    }
+  };
+}
+function nextMacrotask() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+function drain(stream) {
+  return new Promise((resolve) => {
+    if (stream.writableEnded || stream.destroyed) {
+      resolve();
+      return;
+    }
+    try {
+      stream.write("", () => resolve());
+    } catch {
+      resolve();
+    }
+  });
+}
+
+export {
+  onInkAnnotationChange,
+  observeInkTree,
+  canPublishInkGeometry,
+  PACKAGE_VERSION,
+  probeInfo,
+  createInkSession
+};
+//# sourceMappingURL=chunk-Y5WYMWRU.js.map

package/dist/chunk-Y5WYMWRU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/annotations.ts","../src/observe.ts","../src/geometry.ts","../src/version.ts","../src/session.ts"],"sourcesContent":["import type {\n  ProbeAnnotations,\n  ProtocolLimits,\n} from '@termwright/protocol';\nimport { validateProbeAnnotations } from '@termwright/protocol';\n\nconst REGISTRY = Symbol.for('termwright.annotation.ink.v1');\n\ninterface StoredAnnotation {\n  readonly role?: unknown;\n  readonly name?: unknown;\n  readonly description?: unknown;\n  readonly testId?: unknown;\n  readonly extended?: unknown;\n  readonly actions?: unknown;\n  readonly labelledBy?: readonly WeakRef<object>[];\n  readonly describedBy?: readonly WeakRef<object>[];\n}\n\ninterface AnnotationSlot {\n  readonly current?: StoredAnnotation;\n}\n\ninterface AnnotationChannel {\n  readonly entries: WeakMap<object, AnnotationSlot>;\n  readonly listeners: Set<() => void>;\n}\n\nfunction channel(): AnnotationChannel {\n  const scope = globalThis as Record<PropertyKey, unknown>;\n  const present = scope[REGISTRY] as Partial<AnnotationChannel> | undefined;\n  if (present?.entries instanceof WeakMap && present.listeners instanceof Set) {\n    return present as AnnotationChannel;\n  }\n  const created: AnnotationChannel = {\n    entries: new WeakMap<object, AnnotationSlot>(),\n    listeners: new Set<() => void>(),\n  };\n  Object.defineProperty(scope, REGISTRY, { configurable: true, value: created });\n  return created;\n}\n\n/** Re-capture after an annotation attaches to a newly reconciled host. */\nexport function onInkAnnotationChange(handler: () => void): () => void {\n  const listeners = channel().listeners;\n  listeners.add(handler);\n  return () => listeners.delete(handler);\n}\n\nfunction strings(\n  refs: unknown,\n  idFor: (node: object) => string,\n  maxTargets: number,\n): string[] | null | undefined {\n  if (refs === undefined) return undefined;\n  if (!Array.isArray(refs)) return null;\n  const length = Object.getOwnPropertyDescriptor(refs, 'length')?.value;\n  if (!Number.isSafeInteger(length) || length < 0 || length > maxTargets) return null;\n  const ids: string[] = [];\n  for (let index = 0; index < length; index += 1) {\n    try {\n      const descriptor = Object.getOwnPropertyDescriptor(refs, String(index));\n      if (descriptor === undefined || !('value' in descriptor)) return null;\n      const ref = descriptor.value;\n      if (!(ref instanceof WeakRef)) return null;\n      const target = WeakRef.prototype.deref.call(ref) as object | undefined;\n      if (target !== undefined) ids.push(idFor(target));\n    } catch {\n      return null;\n    }\n  }\n  return ids.length === 0 ? undefined : ids;\n}\n\nfunction ownData(value: object, key: keyof StoredAnnotation): unknown {\n  const descriptor = Object.getOwnPropertyDescriptor(value, key);\n  return descriptor !== undefined && 'value' in descriptor ? descriptor.value : undefined;\n}\n\n/** Read author intent without taking a runtime dependency on the optional SDK. */\nexport function annotationForInkNode(\n  node: object,\n  idFor: (node: object) => string,\n  limits: ProtocolLimits,\n): ProbeAnnotations | undefined {\n  try {\n    const slot = channel().entries.get(node);\n    const value = slot?.current;\n    if (value === undefined) return undefined;\n    const role = ownData(value, 'role');\n    const name = ownData(value, 'name');\n    const description = ownData(value, 'description');\n    const testId = ownData(value, 'testId');\n    const extended = ownData(value, 'extended');\n    const actions = ownData(value, 'actions');\n    const labelledBy = strings(ownData(value, 'labelledBy'), idFor, limits.maxRelationTargets);\n    const describedBy = strings(ownData(value, 'describedBy'), idFor, limits.maxRelationTargets);\n    const candidate = {\n      ...(role === undefined ? {} : { role }),\n      ...(name === undefined ? {} : { name }),\n      ...(description === undefined ? {} : { description }),\n      ...(testId === undefined ? {} : { testId }),\n      ...(extended === undefined ? {} : { extended }),\n      ...(actions === undefined ? {} : { actions }),\n      ...(labelledBy === undefined ? {} : { labelledBy }),\n      ...(describedBy === undefined ? {} : { describedBy }),\n    };\n    if (Object.keys(candidate).length === 0) return undefined;\n    const validated = validateProbeAnnotations(candidate, limits);\n    return validated.ok ? validated.annotations : undefined;\n  } catch {\n    return undefined;\n  }\n}\n","/** Ink's retained host tree to framework-neutral Probe IR. */\n\nimport type {\n  ProbeAccessibilityHints,\n  ProbeFrame,\n  ProbeObject,\n  ProbeObservedState,\n  ProbeRect,\n  ProbeUnobservableField,\n  ProtocolLimits,\n} from '@termwright/protocol';\nimport { annotationForInkNode } from './annotations.js';\n\n/** Structural subset of Ink's DOM node. No runtime import from `ink`. */\nexport interface InkDomElement {\n  readonly nodeName: 'ink-root' | 'ink-box' | 'ink-text' | 'ink-virtual-text';\n  readonly childNodes: readonly InkDomNode[];\n  readonly parentNode?: InkDomElement;\n  readonly style?: { readonly display?: string };\n  readonly internal_static?: boolean;\n  readonly staticNode?: InkDomElement;\n  readonly internal_accessibility?: {\n    readonly role?: string;\n    readonly state?: {\n      readonly checked?: boolean;\n      readonly disabled?: boolean;\n      readonly expanded?: boolean;\n      readonly readonly?: boolean;\n      readonly selected?: boolean;\n      readonly busy?: boolean;\n      readonly multiline?: boolean;\n    };\n  };\n}\n\nexport interface InkTextNode {\n  readonly nodeName: '#text';\n  readonly nodeValue: string;\n  readonly parentNode?: InkDomElement;\n}\n\nexport type InkDomNode = InkDomElement | InkTextNode;\n\n/** Public Ink measurement function, kept injectable for tests and isolation. */\nexport type MeasureElement = (\n  node: InkDomElement,\n) => { readonly x: number; readonly y: number; readonly width: number; readonly height: number };\n\nexport interface ObserveInkOptions {\n  readonly frame: number;\n  readonly limits: ProtocolLimits;\n  /** The probe's own hidden Box. It is the sole injected node and is omitted. */\n  readonly excluded?: InkDomElement | null;\n  readonly measureElement?: MeasureElement;\n  /** Only true when live-region coordinates are proven viewport-absolute. */\n  readonly includeGeometry?: boolean;\n}\n\nexport interface InkObservation {\n  readonly frame: ProbeFrame;\n  readonly truncated: boolean;\n}\n\nconst isElement = (node: InkDomNode): node is InkDomElement => node.nodeName !== '#text';\n\n/**\n * Observe every Ink host element, including plain unannotated layout boxes.\n *\n * Source component names do not survive Ink's reconciler. `frameworkType` is\n * therefore deliberately one of Ink's four host kinds; inventing `Button` or\n * a component stack here would be false provenance.\n */\nexport function observeInkTree(root: InkDomElement, options: ObserveInkOptions): InkObservation {\n  const objects: ProbeObject[] = [];\n  const ids = identityStore(root);\n  let truncated = false;\n\n  const visit = (\n    node: InkDomElement,\n    parent: InkDomElement | undefined,\n    depth: number,\n    ancestorHidden: boolean,\n  ): void => {\n    if (node === options.excluded) return;\n    if (depth > options.limits.maxDepth || objects.length >= options.limits.maxNodes) {\n      truncated = true;\n      return;\n    }\n\n    const hidden = ancestorHidden || node.style?.display === 'none';\n    const state = observedState(node, !hidden);\n    const annotations = annotationForInkNode(\n      node,\n      (target) => ids.idFor(target as InkDomElement),\n      options.limits,\n    );\n    const accessibility = observedAccessibility(node);\n    const geometry = geometryOf(node, options);\n    // Probe IR's `text` is the object's own text, never a descendant-derived\n    // accessible name. The recognizer applies name-from-content over the tree.\n    const text = isTextHost(node) ? textOf(node, options.limits.maxStringBytes) : undefined;\n    const unobservable = unobservableFor(node, geometry !== undefined, text !== undefined);\n\n    objects.push({\n      identity: { kind: 'stable', value: ids.idFor(node) },\n      frameworkType: node.nodeName,\n      ...(parent === undefined ? {} : { parent: ids.idFor(parent) }),\n      ...(geometry === undefined ? {} : { geometry: { intendedRect: geometry } }),\n      ...(state === undefined ? {} : { state }),\n      ...(text === undefined ? {} : { text }),\n      ...(accessibility === undefined ? {} : { accessibility }),\n      ...(annotations === undefined ? {} : { annotations }),\n      unobservable,\n    });\n\n    for (const child of node.childNodes) {\n      // Raw `#text` values are payload owned by their `ink-text` host, not a\n      // fifth host kind. The text is retained on that host above.\n      if (isElement(child)) visit(child, node, depth + 1, hidden);\n    }\n  };\n\n  visit(root, undefined, 0, false);\n  return { frame: { frame: options.frame, objects }, truncated };\n}\n\n/** Weak identity is stable for exactly the lifetime of Ink's host object. */\nconst stores = new WeakMap<InkDomElement, IdentityStore>();\n\ninterface IdentityStore {\n  idFor(node: InkDomElement): string;\n}\n\nfunction identityStore(root: InkDomElement): IdentityStore {\n  let store = stores.get(root);\n  if (store !== undefined) return store;\n  const ids = new WeakMap<InkDomElement, string>();\n  let nextId = 0;\n  store = {\n    idFor(node) {\n      const existing = ids.get(node);\n      if (existing !== undefined) return existing;\n      nextId += 1;\n      const id = String(nextId);\n      ids.set(node, id);\n      return id;\n    },\n  };\n  stores.set(root, store);\n  return store;\n}\n\nfunction isTextHost(node: InkDomElement): boolean {\n  return node.nodeName === 'ink-text' || node.nodeName === 'ink-virtual-text';\n}\n\nfunction observedAccessibility(node: InkDomElement): ProbeAccessibilityHints | undefined {\n  const role = node.internal_accessibility?.role;\n  return role === undefined ? undefined : { role };\n}\n\nfunction observedState(node: InkDomElement, displayed: boolean): ProbeObservedState | undefined {\n  const accessibility = node.internal_accessibility?.state;\n  const state: ProbeObservedState = {\n    displayed,\n    ...(accessibility?.checked === undefined ? {} : { checked: accessibility.checked }),\n    ...(accessibility?.disabled === undefined ? {} : { disabled: accessibility.disabled }),\n    ...(accessibility?.expanded === undefined ? {} : { expanded: accessibility.expanded }),\n    ...(accessibility?.readonly === undefined ? {} : { readonly: accessibility.readonly }),\n    ...(accessibility?.selected === undefined ? {} : { selected: accessibility.selected }),\n    ...(accessibility?.busy === undefined ? {} : { busy: accessibility.busy }),\n    ...(accessibility?.multiline === undefined ? {} : { multiline: accessibility.multiline }),\n  };\n  return state;\n}\n\nfunction geometryOf(\n  node: InkDomElement,\n  options: ObserveInkOptions,\n): ProbeRect | undefined {\n  if (options.includeGeometry !== true || options.measureElement === undefined) return undefined;\n  if (node.nodeName === 'ink-virtual-text') return undefined;\n  try {\n    const measured = options.measureElement(node);\n    if (\n      !Number.isFinite(measured.x)\n      || !Number.isFinite(measured.y)\n      || !Number.isFinite(measured.width)\n      || !Number.isFinite(measured.height)\n      || measured.width <= 0\n      || measured.height <= 0\n    ) return undefined;\n    return {\n      row: Math.trunc(measured.y),\n      column: Math.trunc(measured.x),\n      width: Math.trunc(measured.width),\n      height: Math.trunc(measured.height),\n    };\n  } catch {\n    return undefined;\n  }\n}\n\nfunction textOf(node: InkDomElement, maxBytes: number): string | undefined {\n  const parts: string[] = [];\n  let bytes = 0;\n\n  const append = (value: string): void => {\n    for (const codePoint of value) {\n      const size = Buffer.byteLength(codePoint, 'utf8');\n      if (bytes + size > maxBytes) return;\n      parts.push(codePoint);\n      bytes += size;\n    }\n  };\n\n  // Raw #text children are this host's payload. Nested host elements retain\n  // their own ProbeObjects, so folding them in here would violate the IR's\n  // own-text contract and duplicate them during name-from-content inference.\n  for (const child of node.childNodes) {\n    if (bytes >= maxBytes) break;\n    if (!isElement(child)) append(child.nodeValue);\n  }\n  const text = parts.join('').replace(/\\s+/gu, ' ').trim();\n  return text.length === 0 ? undefined : text;\n}\n\nfunction unobservableFor(\n  node: InkDomElement,\n  hasGeometry: boolean,\n  hasText: boolean,\n): readonly ProbeUnobservableField[] {\n  const result: ProbeUnobservableField[] = [\n    'focused',\n    'value',\n    'selectedIndex',\n    'textSelection',\n    'scroll',\n    'scrollExtent',\n    'visibleRect',\n    'paintOrder',\n  ];\n  const state = node.internal_accessibility?.state;\n  if (state?.disabled === undefined) result.push('disabled');\n  if (state?.checked === undefined) result.push('checked');\n  if (state?.expanded === undefined) result.push('expanded');\n  if (state?.readonly === undefined) result.push('readonly');\n  if (state?.selected === undefined) result.push('selected');\n  if (state?.busy === undefined) result.push('busy');\n  if (state?.multiline === undefined) result.push('multiline');\n  if (!hasGeometry) result.push('intendedRect');\n  if (!hasText && isTextHost(node)) result.push('text');\n  return result;\n}\n\n/** `<Static>` moves the live region down by an offset Ink does not expose. */\nexport function hasStaticContent(root: InkDomElement): boolean {\n  const stack: InkDomElement[] = [root];\n  while (stack.length > 0) {\n    const node = stack.pop() as InkDomElement;\n    if (node.internal_static === true || node.staticNode !== undefined) return true;\n    for (const child of node.childNodes) if (isElement(child)) stack.push(child);\n  }\n  return false;\n}\n","/** Truthful gate for Ink's live-region coordinates. */\n\nexport interface GeometryGateOptions {\n  readonly alternateScreen: boolean;\n  readonly interactive?: boolean;\n  readonly stdoutIsTTY: boolean;\n  /** Injectable only so the default-interactivity branch is deterministic. */\n  readonly inCi?: boolean;\n}\n\n/**\n * Reproduce Ink 7's `resolveInteractiveOption` and\n * `resolveAlternateScreenOption`. Layout coordinates are terminal-absolute\n * only if Ink actually entered the alternate screen on a TTY.\n */\nexport function canPublishInkGeometry(options: GeometryGateOptions): boolean {\n  const interactive = options.interactive\n    ?? (!(options.inCi ?? runningInCi()) && options.stdoutIsTTY);\n  return options.alternateScreen && interactive && options.stdoutIsTTY;\n}\n\nfunction runningInCi(): boolean {\n  return enabledEnvironmentFlag('CI') || enabledEnvironmentFlag('CONTINUOUS_INTEGRATION');\n}\n\nfunction enabledEnvironmentFlag(name: string): boolean {\n  const value = process.env[name];\n  return value !== undefined && value !== '0' && value !== 'false';\n}\n","/** Synchronized from package.json by scripts/sync-protocol-version.mjs. */\nexport const PACKAGE_VERSION = '0.2.0';\n","/** A committed Ink host tree to snapshot/commit/marker publication. */\n\nimport type { ProbeInfo, ProtocolLimits, SemanticSnapshot } from '@termwright/protocol';\nimport { recognize } from '@termwright/recognizers';\nimport type { ProbeChannel } from '@termwright/probe-runtime';\nimport {\n  hasStaticContent,\n  observeInkTree,\n  type InkDomElement,\n  type MeasureElement,\n} from './observe.js';\nimport { PACKAGE_VERSION } from './version.js';\n\n/** What this probe truthfully offers at handshake time. */\nexport function probeInfo(): ProbeInfo {\n  return {\n    framework: 'ink',\n    probeVersion: PACKAGE_VERSION,\n    identityKind: 'stable',\n    // The optional @termwright/ink SDK writes author intent to the shared weak\n    // registry. Ink's own aria metadata travels separately as framework facts.\n    capabilities: ['stable-identity', 'annotations'],\n  };\n}\n\nexport interface InkSessionOptions {\n  readonly channel: ProbeChannel;\n  readonly resolveRoot: () => InkDomElement | null;\n  readonly resolveExcluded?: () => InkDomElement | null;\n  readonly measureElement: MeasureElement;\n  readonly stdout: NodeJS.WriteStream;\n  readonly includeGeometry: boolean;\n}\n\nexport interface InkProbeSession {\n  readonly revision: number;\n  readonly frames: number;\n  notifyRender(): void;\n  /** Settle all captures queued at the time of the call. Never rejects. */\n  flush(): Promise<void>;\n  stop(): void;\n}\n\n/**\n * Pair each observed commit with its output bytes.\n *\n * Ink invokes `onRender` after layout and before writing. The tree is frozen\n * synchronously in that callback; deferring observation would let a microtask\n * or a throttled commit mutate the host objects before they were read. Only\n * marker placement is deferred: after Ink returns and writes, stdout is\n * drained and the authenticated marker is appended.\n */\nexport function createInkSession(options: InkSessionOptions): InkProbeSession {\n  let revision = 0;\n  let frames = 0;\n  let latestFrame = 0;\n  let staticSeen = false;\n  let stopped = false;\n  let queue: Promise<void> = Promise.resolve();\n\n  const fail = (): void => {\n    if (stopped) return;\n    stopped = true;\n    options.channel.close();\n  };\n\n  const writeMarker = async (frame: number, marker: string): Promise<void> => {\n    await nextMacrotask();\n    if (stopped || !options.channel.isOpen) return;\n    if (frame !== latestFrame) {\n      options.channel.recordCoalescedEvent();\n      return;\n    }\n    await drain(options.stdout);\n    // A newer render may have written while this drain was pending. Marker N\n    // after frame N+1 bytes is actively misleading, so drop it and let the\n    // newer full snapshot establish the next pairing.\n    if (stopped || !options.channel.isOpen) return;\n    if (frame !== latestFrame) {\n      options.channel.recordCoalescedEvent();\n      return;\n    }\n    options.stdout.write(marker);\n  };\n\n  return {\n    get revision() {\n      return revision;\n    },\n    get frames() {\n      return frames;\n    },\n    notifyRender() {\n      if (stopped) return;\n      frames += 1;\n      const frame = frames;\n      // Even an unobservable/failed frame supersedes a queued old marker.\n      latestFrame = frame;\n\n      try {\n        const root = options.resolveRoot();\n        if (root === null) return;\n        // Static output scrolls the live region down. Removing <Static> later\n        // does not erase bytes already written above it, so loss of absolute\n        // coordinates is sticky for this session.\n        staticSeen ||= hasStaticContent(root);\n        const includeGeometry = options.includeGeometry && !staticSeen;\n        const excluded = options.resolveExcluded?.();\n        const observation = observeInkTree(root, {\n          frame,\n          limits: options.channel.session.limits as ProtocolLimits,\n          ...(excluded === undefined ? {} : { excluded }),\n          measureElement: options.measureElement,\n          includeGeometry,\n        });\n\n        revision += 1;\n        const snapshot: SemanticSnapshot = recognize(observation.frame, {\n          sessionId: options.channel.session.sessionId,\n          revision,\n          columns: options.stdout.columns ?? 80,\n          rows: options.stdout.rows ?? 24,\n          framework: 'ink',\n          paintOrderKnown: false,\n          maxStringBytes: options.channel.session.limits.maxStringBytes,\n          qualified: options.channel.session.protocol === 'termwright/2',\n        });\n        const marker = options.channel.publish(snapshot, {\n          probeEvents: observation.frame.objects.length + (observation.frame.operations?.length ?? 0),\n        });\n        if (marker === undefined) return;\n        queue = queue.then(() => writeMarker(frame, marker)).catch(fail);\n      } catch {\n        fail();\n      }\n    },\n    async flush() {\n      await queue.catch(() => undefined);\n    },\n    stop() {\n      fail();\n    },\n  };\n}\n\nfunction nextMacrotask(): Promise<void> {\n  return new Promise((resolve) => setImmediate(resolve));\n}\n\nfunction drain(stream: NodeJS.WriteStream): Promise<void> {\n  return new Promise((resolve) => {\n    if (stream.writableEnded || stream.destroyed) {\n      resolve();\n      return;\n    }\n    try {\n      stream.write('', () => resolve());\n    } catch {\n      resolve();\n    }\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+import { P as ProbeRuntime, I as InkDomElement, M as MeasureElement } from './observe-C853n-dp.js';
+export { E as EnvSource, a as InkDomNode, b as InkObservation, i as isInstrumented, o as observeInkTree } from './observe-C853n-dp.js';
+import { ProbeInfo } from '@termwright/protocol';
+import { ProbeChannel } from '@termwright/probe-runtime';
+
+/** Build an application command with the zero-config Ink preload attached. */
+
+/** Published preload paths; callers never have to guess package layout. */
+declare const PROBE_ENTRIES: {
+    readonly bun: string;
+    readonly node: string;
+};
+interface ProbeCommand {
+    readonly command: readonly string[];
+    readonly runtime: ProbeRuntime;
+}
+/** Prefix a normal Node or Bun command with the matching preload flag. */
+declare function withProbe(runtime: ProbeRuntime, argv: readonly string[]): ProbeCommand;
+
+/** Replacement source for Ink's public entry module. */
+/** Marker on the shim's re-import of the untouched module. */
+declare const ORIGINAL_MARKER = "termwright-original=1";
+/**
+ * Ink's ESM entry under ordinary node_modules and Bun's versioned cache.
+ * Matching the resolved path, rather than the bare specifier, is required by
+ * both loader APIs used here.
+ */
+declare const INK_ENTRY_PATTERN: RegExp;
+/** The separately-built runtime imported by replacement module source. */
+declare const INSTRUMENT_URL: string;
+declare function shouldShim(urlOrPath: string): boolean;
+declare function originalUrl(urlOrPath: string): string;
+/**
+ * Forward the complete Ink namespace and shadow only `render`.
+ *
+ * The wrapper receives the already-marked original namespace, so the runtime
+ * never imports `ink` itself and cannot recurse through the loader hook.
+ */
+declare function buildShimSource(target: string, instrumentUrl?: string): string;
+
+/** Truthful gate for Ink's live-region coordinates. */
+interface GeometryGateOptions {
+    readonly alternateScreen: boolean;
+    readonly interactive?: boolean;
+    readonly stdoutIsTTY: boolean;
+    /** Injectable only so the default-interactivity branch is deterministic. */
+    readonly inCi?: boolean;
+}
+/**
+ * Reproduce Ink 7's `resolveInteractiveOption` and
+ * `resolveAlternateScreenOption`. Layout coordinates are terminal-absolute
+ * only if Ink actually entered the alternate screen on a TTY.
+ */
+declare function canPublishInkGeometry(options: GeometryGateOptions): boolean;
+
+/** A committed Ink host tree to snapshot/commit/marker publication. */
+
+/** What this probe truthfully offers at handshake time. */
+declare function probeInfo(): ProbeInfo;
+interface InkSessionOptions {
+    readonly channel: ProbeChannel;
+    readonly resolveRoot: () => InkDomElement | null;
+    readonly resolveExcluded?: () => InkDomElement | null;
+    readonly measureElement: MeasureElement;
+    readonly stdout: NodeJS.WriteStream;
+    readonly includeGeometry: boolean;
+}
+interface InkProbeSession {
+    readonly revision: number;
+    readonly frames: number;
+    notifyRender(): void;
+    /** Settle all captures queued at the time of the call. Never rejects. */
+    flush(): Promise<void>;
+    stop(): void;
+}
+/**
+ * Pair each observed commit with its output bytes.
+ *
+ * Ink invokes `onRender` after layout and before writing. The tree is frozen
+ * synchronously in that callback; deferring observation would let a microtask
+ * or a throttled commit mutate the host objects before they were read. Only
+ * marker placement is deferred: after Ink returns and writes, stdout is
+ * drained and the authenticated marker is appended.
+ */
+declare function createInkSession(options: InkSessionOptions): InkProbeSession;
+
+export { type GeometryGateOptions, INK_ENTRY_PATTERN, INSTRUMENT_URL, InkDomElement, type InkProbeSession, type InkSessionOptions, MeasureElement, ORIGINAL_MARKER, PROBE_ENTRIES, type ProbeCommand, ProbeRuntime, buildShimSource, canPublishInkGeometry, createInkSession, originalUrl, probeInfo, shouldShim, withProbe };

package/dist/index.js

@@ -0,0 +1,54 @@
+import {
+  canPublishInkGeometry,
+  createInkSession,
+  observeInkTree,
+  probeInfo
+} from "./chunk-Y5WYMWRU.js";
+import {
+  INK_ENTRY_PATTERN,
+  INSTRUMENT_URL,
+  ORIGINAL_MARKER,
+  buildShimSource,
+  originalUrl,
+  shouldShim
+} from "./chunk-IUFXTMZ7.js";
+import {
+  isInstrumented
+} from "./chunk-LO7YF74P.js";
+
+// src/launch.ts
+import { fileURLToPath, pathToFileURL } from "url";
+var PROBE_ENTRIES = {
+  bun: fileURLToPath(new URL("./bun-preload.js", import.meta.url)),
+  node: fileURLToPath(new URL("./node-hook.js", import.meta.url))
+};
+function withProbe(runtime, argv) {
+  if (argv.length === 0) throw new Error("withProbe needs an interpreter in argv");
+  const [interpreter, ...rest] = argv;
+  const flag = runtime === "bun" ? "--preload" : "--import";
+  return {
+    command: [
+      interpreter,
+      flag,
+      pathToFileURL(PROBE_ENTRIES[runtime]).href,
+      ...rest
+    ],
+    runtime
+  };
+}
+export {
+  INK_ENTRY_PATTERN,
+  INSTRUMENT_URL,
+  ORIGINAL_MARKER,
+  PROBE_ENTRIES,
+  buildShimSource,
+  canPublishInkGeometry,
+  createInkSession,
+  isInstrumented,
+  observeInkTree,
+  originalUrl,
+  probeInfo,
+  shouldShim,
+  withProbe
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/launch.ts"],"sourcesContent":["/** Build an application command with the zero-config Ink preload attached. */\n\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport type { ProbeRuntime } from './runtime.js';\n\n/** Published preload paths; callers never have to guess package layout. */\nexport const PROBE_ENTRIES = {\n  bun: fileURLToPath(new URL('./bun-preload.js', import.meta.url)),\n  node: fileURLToPath(new URL('./node-hook.js', import.meta.url)),\n} as const;\n\nexport interface ProbeCommand {\n  readonly command: readonly string[];\n  readonly runtime: ProbeRuntime;\n}\n\n/** Prefix a normal Node or Bun command with the matching preload flag. */\nexport function withProbe(runtime: ProbeRuntime, argv: readonly string[]): ProbeCommand {\n  if (argv.length === 0) throw new Error('withProbe needs an interpreter in argv');\n  const [interpreter, ...rest] = argv as [string, ...string[]];\n  const flag = runtime === 'bun' ? '--preload' : '--import';\n  return {\n    command: [\n      interpreter,\n      flag,\n      pathToFileURL(PROBE_ENTRIES[runtime]).href,\n      ...rest,\n    ],\n    runtime,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAEA,SAAS,eAAe,qBAAqB;AAItC,IAAM,gBAAgB;AAAA,EAC3B,KAAK,cAAc,IAAI,IAAI,oBAAoB,YAAY,GAAG,CAAC;AAAA,EAC/D,MAAM,cAAc,IAAI,IAAI,kBAAkB,YAAY,GAAG,CAAC;AAChE;AAQO,SAAS,UAAU,SAAuB,MAAuC;AACtF,MAAI,KAAK,WAAW,EAAG,OAAM,IAAI,MAAM,wCAAwC;AAC/E,QAAM,CAAC,aAAa,GAAG,IAAI,IAAI;AAC/B,QAAM,OAAO,YAAY,QAAQ,cAAc;AAC/C,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,MACA;AAAA,MACA,cAAc,cAAc,OAAO,CAAC,EAAE;AAAA,MACtC,GAAG;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/instrument.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode, ComponentType } from 'react';
+import { RenderOptions, Instance } from 'ink';
+import { M as MeasureElement, E as EnvSource } from './observe-C853n-dp.js';
+import '@termwright/protocol';
+
+/** The render wrapper imported by the replacement Ink entry module. */
+
+type InkRender = (node: ReactNode, options?: NodeJS.WriteStream | RenderOptions) => Instance;
+/** Runtime Ink surface forwarded by the shim, kept structural to avoid cycles. */
+interface InkModule {
+    readonly render: InkRender;
+    readonly Box: ComponentType<Record<string, unknown>>;
+    readonly measureElement: MeasureElement;
+}
+/** @internal Used only by the in-process component harness. */
+interface InstrumentInkOptions {
+    readonly env?: EnvSource;
+}
+/**
+ * Wrap the original `ink.render` while preserving every other Ink export.
+ * With no complete driver environment this function calls the original render
+ * directly, without even creating the hidden ref used by an active session.
+ */
+declare function wrapInkRender(ink: InkModule, options?: InstrumentInkOptions): InkRender;
+
+export { type InkModule, type InstrumentInkOptions, wrapInkRender };

package/dist/instrument.js

@@ -0,0 +1,134 @@
+import {
+  PACKAGE_VERSION,
+  canPublishInkGeometry,
+  createInkSession,
+  onInkAnnotationChange,
+  probeInfo
+} from "./chunk-Y5WYMWRU.js";
+import {
+  isInstrumented
+} from "./chunk-LO7YF74P.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 { connectProbe } from "@termwright/probe-runtime";
+var ADAPTER_NAME = "@termwright/probe-ink";
+var ADAPTER_VERSION = PACKAGE_VERSION;
+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);
+    }
+  };
+  Object.defineProperty(wrapped, "__termwright__", { value: true });
+  return wrapped;
+}
+function instrumentedRender(ink, node, suppliedOptions, env) {
+  const options = normalizeOptions(suppliedOptions);
+  const stdout = options.stdout ?? process.stdout;
+  const probeRef = { current: null };
+  const state = {
+    channel: null,
+    session: null
+  };
+  let disposed = false;
+  const releaseAnnotations = onInkAnnotationChange(() => state.session?.notifyRender());
+  const wrap = (child) => createElement(
+    Fragment,
+    null,
+    createElement(ink.Box, { ref: probeRef, display: "none" }),
+    child
+  );
+  const userOnRender = options.onRender;
+  const instance = ink.render(wrap(node), {
+    ...options,
+    onRender(metrics) {
+      try {
+        state.session?.notifyRender();
+      } catch {
+        state.session?.stop();
+      }
+      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();
+  };
+  void instance.waitUntilExit().catch(() => void 0).then(async () => {
+    await connection;
+    await state.session?.flush();
+    stop();
+  }).catch(stop);
+  return {
+    ...instance,
+    rerender(next) {
+      instance.rerender(wrap(next));
+    },
+    unmount(error) {
+      return instance.unmount(error);
+    },
+    cleanup() {
+      stop();
+      instance.cleanup();
+    }
+  };
+}
+function normalizeOptions(supplied) {
+  if (supplied === void 0) return {};
+  if (supplied instanceof Stream) {
+    return { stdout: supplied };
+  }
+  return supplied;
+}
+export {
+  wrapInkRender
+};
+//# sourceMappingURL=instrument.js.map

package/dist/instrument.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/instrument.ts"],"sourcesContent":["/** The render wrapper imported by the replacement Ink entry module. */\n\nimport { Stream } from 'node:stream';\nimport { createElement, Fragment, type ComponentType, type ReactNode } from 'react';\nimport type { DOMElement, Instance, RenderOptions } from 'ink';\nimport type { AdapterCapability } from '@termwright/protocol';\nimport { ENV_ENDPOINT, ENV_PROTOCOL, ENV_TOKEN, PROTOCOL_V2_ID } from '@termwright/protocol';\nimport { connectProbe, type ProbeChannel } from '@termwright/probe-runtime';\nimport { canPublishInkGeometry } from './geometry.js';\nimport type { InkDomElement, MeasureElement } from './observe.js';\nimport { createInkSession, probeInfo, type InkProbeSession } from './session.js';\nimport { isInstrumented } from './runtime.js';\nimport type { EnvSource } from './runtime.js';\nimport { PACKAGE_VERSION } from './version.js';\nimport { onInkAnnotationChange } from './annotations.js';\n\nconst ADAPTER_NAME = '@termwright/probe-ink';\nconst ADAPTER_VERSION = PACKAGE_VERSION;\n\ntype InkRender = (\n  node: ReactNode,\n  options?: NodeJS.WriteStream | RenderOptions,\n) => Instance;\n\n/** Runtime Ink surface forwarded by the shim, kept structural to avoid cycles. */\nexport interface InkModule {\n  readonly render: InkRender;\n  readonly Box: ComponentType<Record<string, unknown>>;\n  readonly measureElement: MeasureElement;\n}\n\n/** @internal Used only by the in-process component harness. */\nexport interface InstrumentInkOptions {\n  readonly env?: EnvSource;\n}\n\n/**\n * Wrap the original `ink.render` while preserving every other Ink export.\n * With no complete driver environment this function calls the original render\n * directly, without even creating the hidden ref used by an active session.\n */\nexport function wrapInkRender(ink: InkModule, options: InstrumentInkOptions = {}): InkRender {\n  const env = options.env ?? process.env;\n  const wrapped: InkRender = (node, suppliedOptions) => {\n    if (!isInstrumented(env)) return ink.render(node, suppliedOptions);\n\n    try {\n      return instrumentedRender(ink, node, suppliedOptions, env);\n    } catch {\n      // Setup failures are probe failures. The application still gets its\n      // ordinary render rather than inheriting our exception.\n      return ink.render(node, suppliedOptions);\n    }\n  };\n  Object.defineProperty(wrapped, '__termwright__', { value: true });\n  return wrapped;\n}\n\nfunction instrumentedRender(\n  ink: InkModule,\n  node: ReactNode,\n  suppliedOptions: NodeJS.WriteStream | RenderOptions | undefined,\n  env: EnvSource,\n): Instance {\n  const options = normalizeOptions(suppliedOptions);\n  const stdout = options.stdout ?? process.stdout;\n  const probeRef: { current: DOMElement | null } = { current: null };\n  const state: { channel: ProbeChannel | null; session: InkProbeSession | null } = {\n    channel: null,\n    session: null,\n  };\n  let disposed = false;\n  const releaseAnnotations = onInkAnnotationChange(() => state.session?.notifyRender());\n\n  const wrap = (child: ReactNode): ReactNode => createElement(\n    Fragment,\n    null,\n    createElement(ink.Box, { ref: probeRef, display: 'none' }),\n    child,\n  );\n\n  const userOnRender = options.onRender;\n  const instance = ink.render(wrap(node), {\n    ...options,\n    onRender(metrics) {\n      try {\n        // Freeze the committed host tree before an application callback can\n        // synchronously schedule or flush another update.\n        state.session?.notifyRender();\n      } catch {\n        state.session?.stop();\n      }\n      userOnRender?.(metrics);\n    },\n  });\n\n  const includeGeometry = canPublishInkGeometry({\n    alternateScreen: options.alternateScreen === true,\n    ...(options.interactive === undefined ? {} : { interactive: options.interactive }),\n    stdoutIsTTY: stdout.isTTY === true,\n  });\n  const baseCapabilities: readonly AdapterCapability[] = includeGeometry\n    ? ['tree', 'bounds', 'absolute-bounds', 'states', 'actions', 'render-revisions']\n    : ['tree', 'states', 'actions', 'render-revisions'];\n  const qualified = env[ENV_PROTOCOL] === PROTOCOL_V2_ID;\n  const capabilities: readonly AdapterCapability[] = qualified\n    ? [...baseCapabilities, 'qualified-observations']\n    : baseCapabilities;\n\n  const connection = connectProbe({\n    endpoint: env[ENV_ENDPOINT] as string,\n    token: env[ENV_TOKEN] as string,\n    probe: probeInfo(),\n    capabilities,\n    adapterName: ADAPTER_NAME,\n    adapterVersion: ADAPTER_VERSION,\n    ...(qualified ? { protocol: PROTOCOL_V2_ID } : {}),\n  })\n    .then(async (channel) => {\n      if (channel === null || disposed) {\n        channel?.close();\n        return;\n      }\n      state.channel = channel;\n      state.session = createInkSession({\n        channel,\n        resolveRoot: () => (probeRef.current?.parentNode as InkDomElement | undefined) ?? null,\n        resolveExcluded: () => probeRef.current as InkDomElement | null,\n        measureElement: ink.measureElement,\n        stdout,\n        includeGeometry,\n      });\n      // The first commit may have beaten the handshake, but the live host tree\n      // can already contain a throttled commit whose bytes are not on screen.\n      // Flush Ink first. If that emits onRender, the newly-installed session\n      // captures it there; otherwise the stable current tree is a safe catch-up.\n      try {\n        await instance.waitUntilRenderFlush();\n      } catch {\n        state.session.stop();\n        return;\n      }\n      if (!disposed && state.session.frames === 0) state.session.notifyRender();\n    })\n    .catch(() => undefined);\n\n  const stop = (): void => {\n    if (disposed) return;\n    disposed = true;\n    releaseAnnotations();\n    state.session?.stop();\n    state.channel?.close();\n  };\n\n  // Natural `useApp().exit()` does not call our wrapped cleanup. Await the\n  // attach attempt and the exact publication queue instead of guessing a\n  // teardown delay; a slow stdout must not lose its final marker.\n  void instance.waitUntilExit()\n    .catch(() => undefined)\n    .then(async () => {\n      await connection;\n      await state.session?.flush();\n      stop();\n    })\n    .catch(stop);\n\n  return {\n    ...instance,\n    rerender(next) {\n      instance.rerender(wrap(next));\n    },\n    unmount(error?: unknown) {\n      return instance.unmount(error as Parameters<Instance['unmount']>[0]);\n    },\n    cleanup() {\n      stop();\n      instance.cleanup();\n    },\n  };\n}\n\nfunction normalizeOptions(\n  supplied: NodeJS.WriteStream | RenderOptions | undefined,\n): RenderOptions {\n  if (supplied === undefined) return {};\n  // Match Ink's own `getOptions` test exactly. A merely stream-shaped options\n  // object must not gain different semantics only because the probe is active.\n  if (supplied instanceof Stream) {\n    return { stdout: supplied as NodeJS.WriteStream };\n  }\n  return supplied as RenderOptions;\n}\n"],"mappings":"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","names":[]}

package/dist/node-hook.d.ts

@@ -0,0 +1,14 @@
+/** Node entry: `node --import @termwright/probe-ink/node-hook app.js`. */
+type LoadResult = {
+    format?: string | null;
+    source?: string | ArrayBufferView | undefined;
+    shortCircuit?: boolean;
+};
+/** Install the best loader API available on the current Node 22+ release. */
+declare function installNodeHook(env?: NodeJS.ProcessEnv): 'sync' | 'thread' | null;
+/** Off-thread loader export for early Node 22 releases. */
+declare function loadHook(url: string, context: unknown, nextLoad: (url: string, context: unknown) => Promise<LoadResult>): Promise<LoadResult>;
+
+declare const NODE_HOOK_PATH: string;
+
+export { NODE_HOOK_PATH, installNodeHook, loadHook as load, loadHook };

package/dist/node-hook.js

@@ -0,0 +1,38 @@
+import {
+  buildShimSource,
+  shouldShim
+} from "./chunk-IUFXTMZ7.js";
+import {
+  isInstrumented
+} from "./chunk-LO7YF74P.js";
+
+// src/node-hook.ts
+import * as nodeModule from "module";
+import { fileURLToPath } from "url";
+function syncLoad(url, context, nextLoad) {
+  if (!shouldShim(url)) return nextLoad(url, context);
+  return { format: "module", shortCircuit: true, source: buildShimSource(url) };
+}
+function installNodeHook(env = process.env) {
+  if (!isInstrumented(env)) return null;
+  const registerHooks2 = nodeModule.registerHooks;
+  if (typeof registerHooks2 === "function") {
+    registerHooks2({ load: syncLoad });
+    return "sync";
+  }
+  nodeModule.register(new URL(import.meta.url), { parentURL: new URL(import.meta.url) });
+  return "thread";
+}
+async function loadHook(url, context, nextLoad) {
+  if (!shouldShim(url)) return nextLoad(url, context);
+  return { format: "module", shortCircuit: true, source: buildShimSource(url) };
+}
+var NODE_HOOK_PATH = fileURLToPath(import.meta.url);
+installNodeHook();
+export {
+  NODE_HOOK_PATH,
+  installNodeHook,
+  loadHook as load,
+  loadHook
+};
+//# sourceMappingURL=node-hook.js.map

package/dist/node-hook.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/node-hook.ts"],"sourcesContent":["/** Node entry: `node --import @termwright/probe-ink/node-hook app.js`. */\n\nimport * as nodeModule from 'node:module';\nimport { fileURLToPath } from 'node:url';\nimport { buildShimSource, shouldShim } from './shim.js';\nimport { isInstrumented } from './runtime.js';\n\ntype LoadResult = {\n  format?: string | null;\n  source?: string | ArrayBufferView | undefined;\n  shortCircuit?: boolean;\n};\ntype NextLoad = (url: string, context: unknown) => LoadResult;\n\nfunction syncLoad(url: string, context: unknown, nextLoad: NextLoad): LoadResult {\n  if (!shouldShim(url)) return nextLoad(url, context);\n  return { format: 'module', shortCircuit: true, source: buildShimSource(url) };\n}\n\n/** Install the best loader API available on the current Node 22+ release. */\nexport function installNodeHook(env: NodeJS.ProcessEnv = process.env): 'sync' | 'thread' | null {\n  if (!isInstrumented(env)) return null;\n  // A named ESM import of `registerHooks` makes early Node 22 fail while\n  // instantiating this module, before a feature check can run. Namespace access\n  // is the compatibility boundary: 22.9 simply yields `undefined`.\n  const registerHooks = (nodeModule as typeof nodeModule & {\n    readonly registerHooks?: (hooks: { load: never }) => unknown;\n  }).registerHooks;\n  if (typeof registerHooks === 'function') {\n    registerHooks({ load: syncLoad as never });\n    return 'sync';\n  }\n  nodeModule.register(new URL(import.meta.url), { parentURL: new URL(import.meta.url) });\n  return 'thread';\n}\n\n/** Off-thread loader export for early Node 22 releases. */\nexport async function loadHook(\n  url: string,\n  context: unknown,\n  nextLoad: (url: string, context: unknown) => Promise<LoadResult>,\n): Promise<LoadResult> {\n  if (!shouldShim(url)) return nextLoad(url, context);\n  return { format: 'module', shortCircuit: true, source: buildShimSource(url) };\n}\n\nexport { loadHook as load };\nexport const NODE_HOOK_PATH = fileURLToPath(import.meta.url);\n\ninstallNodeHook();\n"],"mappings":";;;;;;;;;AAEA,YAAY,gBAAgB;AAC5B,SAAS,qBAAqB;AAW9B,SAAS,SAAS,KAAa,SAAkB,UAAgC;AAC/E,MAAI,CAAC,WAAW,GAAG,EAAG,QAAO,SAAS,KAAK,OAAO;AAClD,SAAO,EAAE,QAAQ,UAAU,cAAc,MAAM,QAAQ,gBAAgB,GAAG,EAAE;AAC9E;AAGO,SAAS,gBAAgB,MAAyB,QAAQ,KAA+B;AAC9F,MAAI,CAAC,eAAe,GAAG,EAAG,QAAO;AAIjC,QAAMA,iBAEH;AACH,MAAI,OAAOA,mBAAkB,YAAY;AACvC,IAAAA,eAAc,EAAE,MAAM,SAAkB,CAAC;AACzC,WAAO;AAAA,EACT;AACA,EAAW,oBAAS,IAAI,IAAI,YAAY,GAAG,GAAG,EAAE,WAAW,IAAI,IAAI,YAAY,GAAG,EAAE,CAAC;AACrF,SAAO;AACT;AAGA,eAAsB,SACpB,KACA,SACA,UACqB;AACrB,MAAI,CAAC,WAAW,GAAG,EAAG,QAAO,SAAS,KAAK,OAAO;AAClD,SAAO,EAAE,QAAQ,UAAU,cAAc,MAAM,QAAQ,gBAAgB,GAAG,EAAE;AAC9E;AAGO,IAAM,iBAAiB,cAAc,YAAY,GAAG;AAE3D,gBAAgB;","names":["registerHooks"]}

package/dist/observe-C853n-dp.d.ts

@@ -0,0 +1,71 @@
+import { ProbeFrame, ProtocolLimits } from '@termwright/protocol';
+
+/** Runtime activation shared by the two preload entry points. */
+/** Runtimes into which the Ink probe can be injected. */
+type ProbeRuntime = 'bun' | 'node';
+/** Read-only environment view, so activation is testable without mutation. */
+type EnvSource = Readonly<Record<string, string | undefined>>;
+/** Both secrets are required. A partial environment remains fully dormant. */
+declare function isInstrumented(env: EnvSource): boolean;
+
+/** Ink's retained host tree to framework-neutral Probe IR. */
+
+/** Structural subset of Ink's DOM node. No runtime import from `ink`. */
+interface InkDomElement {
+    readonly nodeName: 'ink-root' | 'ink-box' | 'ink-text' | 'ink-virtual-text';
+    readonly childNodes: readonly InkDomNode[];
+    readonly parentNode?: InkDomElement;
+    readonly style?: {
+        readonly display?: string;
+    };
+    readonly internal_static?: boolean;
+    readonly staticNode?: InkDomElement;
+    readonly internal_accessibility?: {
+        readonly role?: string;
+        readonly state?: {
+            readonly checked?: boolean;
+            readonly disabled?: boolean;
+            readonly expanded?: boolean;
+            readonly readonly?: boolean;
+            readonly selected?: boolean;
+            readonly busy?: boolean;
+            readonly multiline?: boolean;
+        };
+    };
+}
+interface InkTextNode {
+    readonly nodeName: '#text';
+    readonly nodeValue: string;
+    readonly parentNode?: InkDomElement;
+}
+type InkDomNode = InkDomElement | InkTextNode;
+/** Public Ink measurement function, kept injectable for tests and isolation. */
+type MeasureElement = (node: InkDomElement) => {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+};
+interface ObserveInkOptions {
+    readonly frame: number;
+    readonly limits: ProtocolLimits;
+    /** The probe's own hidden Box. It is the sole injected node and is omitted. */
+    readonly excluded?: InkDomElement | null;
+    readonly measureElement?: MeasureElement;
+    /** Only true when live-region coordinates are proven viewport-absolute. */
+    readonly includeGeometry?: boolean;
+}
+interface InkObservation {
+    readonly frame: ProbeFrame;
+    readonly truncated: boolean;
+}
+/**
+ * Observe every Ink host element, including plain unannotated layout boxes.
+ *
+ * Source component names do not survive Ink's reconciler. `frameworkType` is
+ * therefore deliberately one of Ink's four host kinds; inventing `Button` or
+ * a component stack here would be false provenance.
+ */
+declare function observeInkTree(root: InkDomElement, options: ObserveInkOptions): InkObservation;
+
+export { type EnvSource as E, type InkDomElement as I, type MeasureElement as M, type ProbeRuntime as P, type InkDomNode as a, type InkObservation as b, isInstrumented as i, observeInkTree as o };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@termwright/probe-ink",
+  "version": "0.2.0",
+  "description": "zero-config Ink 7 probe: render interception and host-tree observation",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Gorce-AI/termwright.git",
+    "directory": "packages/probe-ink"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node-hook": {
+      "types": "./dist/node-hook.d.ts",
+      "import": "./dist/node-hook.js"
+    },
+    "./bun-preload": {
+      "types": "./dist/bun-preload.d.ts",
+      "import": "./dist/bun-preload.js"
+    },
+    "./internal/testing": {
+      "types": "./dist/instrument.d.ts",
+      "import": "./dist/instrument.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@termwright/protocol": "0.2.0",
+    "@termwright/probe-runtime": "0.2.0",
+    "@termwright/recognizers": "^0.2.0"
+  },
+  "peerDependencies": {
+    "ink": ">=7.1.0 <8",
+    "react": ">=19.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.18",
+    "ink": "^7.1.1",
+    "react": "^19.2.8",
+    "@termwright/ink": "0.2.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/node-hook.ts src/bun-preload.ts src/instrument.ts --format esm --dts --sourcemap --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}