@ingcreators/annot-product-docs-astro 0.2.2 → 0.3.1

package/dist/components/AnnotEditorIframeModal.astro

@@ -0,0 +1,202 @@
+---
+// `<AnnotEditorIframeModal>` — Phase 5e of
+// `docs/plans/living-spec-authoring-roadmap.md`. The inline-
+// mode counterpart to `<AnnotEditButton>`'s default newTab
+// behaviour. Mount once per page (typically in the docs site's
+// layout) and any `<AnnotEditButton mode="inline">` on the
+// same page opens the modal instead of a new tab.
+//
+// Lazy-loaded: the modal HTML + script only ship if this
+// component is mounted. Pages that only use `mode="newTab"`
+// (the default per OQ-09) never download the modal code.
+// `<AnnotEditButton mode="inline">` on a page without
+// `<AnnotEditorIframeModal />` gracefully degrades to newTab
+// + a one-time `console.warn`.
+//
+// MDX usage in a layout:
+//
+//   ---
+//   import { AnnotEditorIframeModal } from "@ingcreators/annot-product-docs-astro/components/AnnotEditorIframeModal.astro";
+//   ---
+//   <slot />
+//   <AnnotEditorIframeModal />
+//
+// Then any `<AnnotEditButton mode="inline" ... />` in MDX
+// opens the modal on click. The modal listens for
+// `EditCommitted` / `EditAbandoned` / `ResizeNeeded` via the
+// 5c postMessage dispatcher and dismisses itself accordingly.
+
+interface Props {
+  /** Modal aria-label. Overridable for localisation. */
+  ariaLabel?: string;
+}
+
+const { ariaLabel = "Annot editor" } = Astro.props;
+---
+
+<dialog
+  class="annot-editor-iframe-modal"
+  data-annot-edit-modal-root
+  aria-label={ariaLabel}
+>
+  <iframe
+    class="annot-editor-iframe-modal-frame"
+    title={ariaLabel}
+    allow="clipboard-read; clipboard-write"
+    referrerpolicy="origin"
+  ></iframe>
+</dialog>
+
+<script>
+  import {
+    createEmbedHostMessenger,
+    type EmbedEvent,
+    type EmbedMessenger,
+  } from "@ingcreators/annot-embed-protocol";
+
+  interface OpenModalOptions {
+    readonly cloudUrl: string;
+    readonly editorUrl: string;
+  }
+
+  const MAX_HEIGHT_FRACTION = 0.95;
+  const DEFAULT_FRAME_HEIGHT_PX = 720;
+
+  function findModal(): HTMLDialogElement | null {
+    return document.querySelector<HTMLDialogElement>(
+      "dialog[data-annot-edit-modal-root]",
+    );
+  }
+
+  function findFrame(modal: HTMLDialogElement): HTMLIFrameElement | null {
+    return modal.querySelector<HTMLIFrameElement>(
+      "iframe.annot-editor-iframe-modal-frame",
+    );
+  }
+
+  function clampHeight(requested: number): number {
+    if (!Number.isFinite(requested) || requested <= 0) {
+      return DEFAULT_FRAME_HEIGHT_PX;
+    }
+    const max = window.innerHeight * MAX_HEIGHT_FRACTION;
+    return Math.min(requested, max);
+  }
+
+  function openModal(options: OpenModalOptions): void {
+    const modal = findModal();
+    if (!modal) {
+      // biome-ignore lint/suspicious/noConsole: lazy-mount contract violation surfaces here.
+      console.warn(
+        "[<AnnotEditorIframeModal>] dialog element not found — was the component mounted on this page?",
+      );
+      return;
+    }
+    const frame = findFrame(modal);
+    if (!frame) return;
+
+    frame.style.height = `${DEFAULT_FRAME_HEIGHT_PX}px`;
+    frame.src = options.editorUrl;
+
+    let messenger: EmbedMessenger | null = null;
+
+    const teardown = (): void => {
+      if (messenger) {
+        messenger.cleanup();
+        messenger = null;
+      }
+      frame.removeAttribute("src");
+    };
+
+    const onEvent = (event: EmbedEvent): void => {
+      if (event.type === "EditCommitted") {
+        // Forward to the docs-site's `<AnnotEditCompleteListener>` so the
+        // post-edit toast surfaces consistently across newTab + inline
+        // modes (Phase 5g).
+        document.dispatchEvent(
+          new CustomEvent("annot:editor-iframe-committed", {
+            detail: {
+              editId: event.editId,
+              commitSha: event.commitSha,
+              branch: event.branch,
+              prUrl: event.prUrl,
+            },
+          }),
+        );
+        modal.close();
+        return;
+      }
+      if (event.type === "EditAbandoned") {
+        modal.close();
+        return;
+      }
+      if (event.type === "ResizeNeeded") {
+        frame.style.height = `${clampHeight(event.height)}px`;
+      }
+    };
+
+    modal.addEventListener(
+      "close",
+      () => {
+        teardown();
+      },
+      { once: true },
+    );
+
+    // Set up the host messenger after the iframe loads — its
+    // `contentWindow` is null until then. Once loaded, attach
+    // the messenger; subsequent postMessages from the cloud
+    // editor route through it.
+    frame.addEventListener(
+      "load",
+      () => {
+        try {
+          messenger = createEmbedHostMessenger({
+            frame,
+            expectedOrigin: options.cloudUrl,
+            onEvent,
+          });
+        } catch (error) {
+          // biome-ignore lint/suspicious/noConsole: surface failed host-messenger setup.
+          console.error("[<AnnotEditorIframeModal>] failed to attach host messenger:", error);
+          modal.close();
+        }
+      },
+      { once: true },
+    );
+
+    modal.showModal();
+  }
+
+  // Expose the open function for `<AnnotEditButton>`'s inline-
+  // mode click handler to call. Keep the surface narrow — just
+  // `open` — so future expansion (close-from-outside,
+  // post-event listener API) is additive.
+  type ModalApi = {
+    open: (options: OpenModalOptions) => void;
+  };
+  (window as unknown as { __annotEditorIframeModal?: ModalApi }).__annotEditorIframeModal =
+    { open: openModal };
+</script>
+
+<style>
+  .annot-editor-iframe-modal {
+    width: min(95vw, 1280px);
+    max-width: 95vw;
+    max-height: 95vh;
+    padding: 0;
+    border: 0;
+    border-radius: 0.6em;
+    background: var(--annot-editor-modal-bg, #ffffff);
+    box-shadow: 0 0.5em 2em rgba(0, 0, 0, 0.4);
+    overflow: hidden;
+  }
+  .annot-editor-iframe-modal::backdrop {
+    background: rgba(0, 0, 0, 0.5);
+  }
+  .annot-editor-iframe-modal-frame {
+    display: block;
+    width: 100%;
+    min-height: 360px;
+    border: 0;
+  }
+</style>

package/dist/components/Screen.astro

@@ -1,27 +1,47 @@
 ---
 // `<Screen>` — annotated screenshot block.
 //
-// MDX usage:
+// MDX usage (legacy, inline `<Overlay>` callouts):
 //   <Screen id="login" src="./shots/login.png">
 //     <Overlay match={...} number={1}>...</Overlay>
 //   </Screen>
 //
+// MDX usage (Phase 2b, yaml-driven callouts):
+//   <Screen id="login" src="./shots/login.png"
+//           annotations="./annotations/login.yaml">
+//     <AnnotCallout for="o1">...</AnnotCallout>
+//   </Screen>
+//
 // The annotated PNG is produced at build time by the Image
 // Service in `@ingcreators/annot-product-docs-astro` (see
-// `../render.ts`). At render time we just emit an `<img>` that
-// points at the cache hash; the Astro pipeline resolves the
-// final URL.
+// `../render.ts`). When `annotations` is set, the service reads
+// the yaml + composes badges from `overlays[]`; otherwise it
+// resolves the inline `<Overlay match>` children. At render time
+// we just emit an `<img>` that points at the cache hash; the
+// Astro pipeline resolves the final URL.
 
 interface Props {
   id: string;
   src: string;
   alt?: string;
+  /**
+   * Phase 2b of `docs/plans/living-spec-authoring-roadmap.md`.
+   * Path (relative to the MDX file) to an `.annotations.yaml`
+   * file describing the screen's overlays. When set, the Image
+   * Service prefers yaml-driven badge composition over the
+   * legacy inline `<Overlay>` children.
+   */
+  annotations?: string;
 }
-const { id, src, alt } = Astro.props;
+const { id, src, alt, annotations } = Astro.props;
 ---
-<figure class="annot-screen" data-screen-id={id}>
+<figure
+  class="annot-screen"
+  data-screen-id={id}
+  data-annotations-path={annotations}
+>
   <img src={src} alt={alt ?? `Screen ${id}`} loading="lazy" />
-  <div class="annot-screen-overlays" data-screen-overlays={id}>
+  <ol class="annot-screen-overlays" data-screen-overlays={id}>
     <slot />
-  </div>
+  </ol>
 </figure>

package/dist/editor-config-virtual.d.ts

@@ -0,0 +1,12 @@
+import { EmbedMode } from '@ingcreators/annot-embed-protocol';
+export interface ResolvedEditorConfig {
+    readonly embedMode: EmbedMode;
+    readonly cloudUrl: string;
+}
+/**
+ * Phase 5 OSS-side built-in defaults. Mirror the per-component
+ * defaults declared inside `<AnnotEditButton>` (`mode="newTab"`,
+ * `cloudUrl="https://annot.work"`) so consumers without the
+ * integration installed still see consistent behaviour.
+ */
+export declare const ANNOT_EDITOR_CONFIG: ResolvedEditorConfig;

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 export type { CacheKeyInput, FileCache } from './cache.js';
 export { cacheKey, createFileCache, createMemoryCache, RENDER_PIPELINE_VERSION, } from './cache.js';
 export type { GraphDirection, GraphEdge, Match, OverlayIntent, ScreenListEntry, TransitionEntry, } from './components/types.js';
-export type { ProductDocsIntegrationOptions } from './integration.js';
-export { productDocsIntegration } from './integration.js';
+export type { ResolvedEditorConfig } from './editor-config-virtual.js';
+export { ANNOT_EDITOR_CONFIG } from './editor-config-virtual.js';
+export type { ProductDocsEditorOptions, ProductDocsIntegrationOptions, } from './integration.js';
+export { editorConfigVirtualPlugin, productDocsIntegration, resolveEditorConfig, } from './integration.js';
 export type { RenderAnnotatedScreenOptions, RenderResult, } from './render.js';
-export { parseSnapshotBoxes, renderAnnotatedScreen, resolveMdxAnnotations, svgFromBboxAnnotations, } from './render.js';
+export { renderAnnotatedScreen, resolveMdxAnnotations, svgFromBboxAnnotations } from './render.js';

package/dist/index.js

@@ -1,18 +1,179 @@
-import { a as e, c as t, i as n, n as r, o as i, r as a, s as o, t as s } from "./render-BSQOeqPB.js";
-//#region src/integration.ts
-var c = "@ingcreators/annot-product-docs-astro";
-function l(e = {}) {
+import { createHash as e } from "node:crypto";
+import { mkdir as t, readFile as n, writeFile as r } from "node:fs/promises";
+import { dirname as i, isAbsolute as a, join as o, resolve as s } from "node:path";
+import { burnRedactions as c, createAnnotator as l } from "@ingcreators/annot-annotator";
+import { readElementTreePng as u } from "@ingcreators/annot-core";
+import { buildBadgeAnnotations as d, buildBadgeAnnotationsFromYaml as f, buildRasterRedactRegionsFromYaml as p, buildShapeAnnotationsFromYaml as m, elementTreeToBoxedEntries as h, emptyAnnotationsSvg as g, parseAnnotationsYaml as _, parseMdxFile as v, parseSnapshotBoxes as y, resolveMdxAnnotations as b, svgFromBboxAnnotations as x, svgFromBboxAnnotations as S, warnLegacyOverlay as C } from "@ingcreators/annot-product-docs";
+//#region src/cache.ts
+var w = 2;
+function T(t) {
+	let n = e("sha256");
+	return n.update("v2\n"), n.update(t.mdxSource), n.update("\0"), n.update(t.screenId), t.editable && n.update("\0editable"), t.annotationsYamlSource !== void 0 && (n.update("\0annotationsYaml\0"), n.update(t.annotationsYamlSource)), n.digest("hex");
+}
+function E(e) {
+	return {
+		dir: e,
+		async get(t) {
+			try {
+				let r = await n(o(e, `${t}.png`));
+				return new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+			} catch (e) {
+				if (e.code === "ENOENT") return null;
+				throw e;
+			}
+		},
+		async set(n, a) {
+			let s = o(e, `${n}.png`);
+			await t(i(s), { recursive: !0 }), await r(s, a);
+		}
+	};
+}
+function D() {
+	let e = /* @__PURE__ */ new Map();
+	return {
+		dir: ":memory:",
+		async get(t) {
+			return e.get(t) ?? null;
+		},
+		async set(t, n) {
+			e.set(t, n);
+		}
+	};
+}
+//#endregion
+//#region src/editor-config-virtual.ts
+var O = {
+	embedMode: "newTab",
+	cloudUrl: "https://annot.work"
+}, k = "@ingcreators/annot-product-docs-astro", A = {
+	embedMode: "newTab",
+	cloudUrl: "https://annot.work"
+}, j = "virtual:annot-docs/editor-config", M = `\0${j}`, N = "editor-config-virtual";
+function P(e) {
+	return {
+		name: "annot-docs:editor-config-virtual",
+		enforce: "pre",
+		resolveId(e) {
+			return e === j || e.endsWith(`${N}.ts`) || e.endsWith(`${N}.js`) ? M : null;
+		},
+		load(t) {
+			return t === M ? `export const ANNOT_EDITOR_CONFIG = ${JSON.stringify(e)};\n` : null;
+		}
+	};
+}
+function F(e) {
+	return {
+		embedMode: e?.embedMode ?? A.embedMode,
+		cloudUrl: e?.cloudUrl ?? A.cloudUrl
+	};
+}
+function I(e = {}) {
 	let t = {
 		contentDir: e.contentDir ?? "docs",
 		configPath: e.configPath ?? "annot-docs.config.ts",
+		editor: e.editor,
 		verbose: e.verbose ?? !1
-	};
+	}, n = F(t.editor);
 	return {
-		name: c,
-		hooks: { "astro:config:setup": ({ logger: e }) => {
-			t.verbose && e.info(`${c} installed — contentDir=${t.contentDir} configPath=${t.configPath}`);
+		name: k,
+		hooks: { "astro:config:setup": ({ logger: e, updateConfig: r }) => {
+			t.verbose && e.info(`${k} installed — contentDir=${t.contentDir} configPath=${t.configPath} editor.embedMode=${n.embedMode} editor.cloudUrl=${n.cloudUrl}`), r({ vite: { plugins: [P(n)] } });
 		} }
 	};
 }
 //#endregion
-export { e as RENDER_PIPELINE_VERSION, i as cacheKey, o as createFileCache, t as createMemoryCache, s as parseSnapshotBoxes, l as productDocsIntegration, r as renderAnnotatedScreen, a as resolveMdxAnnotations, n as svgFromBboxAnnotations };
+//#region src/render.ts
+async function L(e) {
+	let t = e.cwd ?? process.cwd(), n = a(e.mdxPath) ? e.mdxPath : s(t, e.mdxPath), r = await v(n);
+	if (!r) throw Error(`renderAnnotatedScreen: ${e.mdxPath} has no \`annot:\` frontmatter — cannot render.`);
+	let o = r.screens.find((t) => t.id === e.screenId);
+	if (!o) throw Error(`renderAnnotatedScreen: ${e.mdxPath} has no <Screen id="${e.screenId}"> block.`);
+	let u = R(e.editable), _ = i(n), b = await B(o.annotations, _), x = T({
+		mdxSource: r.source,
+		screenId: e.screenId,
+		editable: u !== null,
+		annotationsYamlSource: b?.source
+	});
+	if (e.cache) {
+		let t = await e.cache.get(x);
+		if (t) return {
+			bytes: t,
+			fromCache: !0,
+			hadBoundingBoxes: !0
+		};
+	}
+	let w = e.basePngBytes ?? await V(r, o.src, _), E = H(w), D, O = z(w);
+	D = O ? h(O) : y(r.commentBlocks.snapshot ?? "");
+	let k = b && b.file.annotations ? p(b.file.annotations, D) : [], A = k.length > 0 ? await c(w, k) : w;
+	!b && o.overlays.length > 0 && C({
+		mdxPath: e.mdxPath,
+		screenId: e.screenId,
+		overlayCount: o.overlays.length
+	});
+	let j = b ? f(b.file.overlays, D, E) : d(o.overlays, D, E), M = [...b && b.file.annotations ? m(b.file.annotations, D, E) : [], ...j], N, P;
+	if (M.length === 0) if (P = k.length > 0, u !== null) {
+		let e = `data:image/png;base64,${Buffer.from(A).toString("base64")}`;
+		N = l({ loadSystemFonts: !0 }).toEditablePng({
+			originalDataUrl: e,
+			annotationsSvg: g(),
+			width: E.width,
+			height: E.height,
+			tags: u.tags
+		});
+	} else N = A;
+	else {
+		let e = `data:image/png;base64,${Buffer.from(A).toString("base64")}`, t = S(M), n = l({ loadSystemFonts: !0 }), r = {
+			originalDataUrl: e,
+			annotationsSvg: t,
+			width: E.width,
+			height: E.height
+		};
+		N = u === null ? n.toPng(r) : n.toEditablePng({
+			...r,
+			tags: u.tags
+		}), P = !0;
+	}
+	return e.cache && await e.cache.set(x, N), {
+		bytes: N,
+		fromCache: !1,
+		hadBoundingBoxes: P
+	};
+}
+function R(e) {
+	return e ? e === !0 ? {} : e : null;
+}
+function z(e) {
+	try {
+		return u(e);
+	} catch {
+		return null;
+	}
+}
+async function B(e, t) {
+	if (!e) return null;
+	let r = a(e) ? e : s(t, e), i;
+	try {
+		i = await n(r, "utf8");
+	} catch (t) {
+		throw Error(`renderAnnotatedScreen: <Screen annotations="${e}"> — failed to read ${r}: ${t.message}`);
+	}
+	return {
+		file: _(i),
+		source: i
+	};
+}
+async function V(e, t, r) {
+	if (!t) throw Error("renderAnnotatedScreen: <Screen src=...> is required — cannot render without a base image.");
+	let i = await n(a(t) ? t : s(r, t));
+	return new Uint8Array(i.buffer, i.byteOffset, i.byteLength);
+}
+function H(e) {
+	if (e.length < 24) throw Error("renderAnnotatedScreen: base PNG too short to contain IHDR.");
+	let t = new DataView(e.buffer, e.byteOffset, e.byteLength);
+	return {
+		width: t.getUint32(16, !1),
+		height: t.getUint32(20, !1)
+	};
+}
+//#endregion
+export { O as ANNOT_EDITOR_CONFIG, w as RENDER_PIPELINE_VERSION, T as cacheKey, E as createFileCache, D as createMemoryCache, P as editorConfigVirtualPlugin, I as productDocsIntegration, L as renderAnnotatedScreen, F as resolveEditorConfig, b as resolveMdxAnnotations, x as svgFromBboxAnnotations };

package/dist/integration.d.ts

@@ -1,4 +1,27 @@
+import { EmbedMode } from '@ingcreators/annot-embed-protocol';
 import { AstroIntegration } from 'astro';
+import { ResolvedEditorConfig } from './editor-config-virtual.js';
+export interface EditorConfigVitePlugin {
+    readonly name: string;
+    readonly enforce?: "pre" | "post";
+    readonly resolveId: (id: string) => string | null;
+    readonly load: (id: string) => string | null;
+}
+export interface ProductDocsEditorOptions {
+    /**
+     * Default embed mode for every `<AnnotEditButton>` in the
+     * site. Per-call `mode` prop wins when set. Defaults to
+     * `"newTab"`.
+     */
+    embedMode?: EmbedMode;
+    /**
+     * Cloud editor origin override for on-prem deployments
+     * (e.g. `"https://annot.internal.example.com"`). Per-call
+     * `cloudUrl` prop wins when set. Defaults to
+     * `"https://annot.work"`.
+     */
+    cloudUrl?: string;
+}
 export interface ProductDocsIntegrationOptions {
     /**
      * Directory (relative to the Astro project root) that contains
@@ -13,6 +36,11 @@ export interface ProductDocsIntegrationOptions {
      * `meta` defaults + per-book template lookups.
      */
     configPath?: string;
+    /**
+     * Project-wide `<AnnotEditButton>` defaults. Phase 5f of
+     * `docs/plans/living-spec-authoring-roadmap.md`.
+     */
+    editor?: ProductDocsEditorOptions;
     /**
      * If `true`, the integration logs a debug line on every
      * config:setup. Useful for verifying the integration is
@@ -20,6 +48,28 @@ export interface ProductDocsIntegrationOptions {
      */
     verbose?: boolean;
 }
+/**
+ * Vite plugin that:
+ *
+ *   1. Generates a virtual module (`virtual:annot-docs/editor-config`)
+ *      exporting the resolved editor config.
+ *
+ *   2. Aliases every import of the package's
+ *      `editor-config-virtual.ts` to the virtual module so
+ *      `<AnnotEditButton>` picks up the project-wide defaults.
+ *
+ * Exported here for vitest. Consumers don't need to import it
+ * directly — `productDocsIntegration` wires it up automatically.
+ */
+export declare function editorConfigVirtualPlugin(resolved: ResolvedEditorConfig): EditorConfigVitePlugin;
+/**
+ * Merge the per-call editor options into the built-in defaults.
+ * Future revision (Phase 5f follow-up if needed) also reads
+ * `annot-docs.config.ts`'s `editor` config + merges in the
+ * middle of this precedence ladder; today the integration
+ * option is the only override layer.
+ */
+export declare function resolveEditorConfig(editor: ProductDocsEditorOptions | undefined): ResolvedEditorConfig;
 /**
  * Astro integration factory. Drop into `astro.config.mjs`:
  *
@@ -28,19 +78,19 @@ export interface ProductDocsIntegrationOptions {
  * import { productDocsIntegration } from "@ingcreators/annot-product-docs-astro";
  *
  * export default defineConfig({
- *   integrations: [productDocsIntegration()],
+ *   integrations: [
+ *     productDocsIntegration({
+ *       editor: {
+ *         embedMode: "newTab",
+ *         cloudUrl: "https://annot.internal.example.com",
+ *       },
+ *     }),
+ *   ],
  * });
  * ```
- *
- * Phase 2 PR 1 ships the scaffold — the hooks are no-ops aside
- * from optional verbose logging. PR 2 adds the Image Service;
- * PR 3 wires up the seven docs components.
  */
 export declare function productDocsIntegration(options?: ProductDocsIntegrationOptions): AstroIntegration;
 /**
  * Default-export shape some Astro integration authors prefer.
- * Both `import productDocsIntegration from ...` (default) and
- * `import { productDocsIntegration }` (named) resolve to the
- * same factory; consumers can pick whichever feels natural.
  */
 export default productDocsIntegration;

package/dist/playwright/index.d.ts

@@ -1,5 +1,36 @@
+/**
+ * @deprecated Import `AnnotScreenshotOptions` from
+ * `@ingcreators/annot-playwright` — that package owns the
+ * canonical interface; `@ingcreators/annot-product-docs` augments
+ * it with `mdx`. Re-exporting here is back-compat only and will
+ * be removed in `@ingcreators/annot-product-docs-astro@0.5.0`.
+ */
+/**
+ * @deprecated Import the rebase helpers (`Clip`, `RebaseResult`,
+ * `describeAnnotation`, `rebaseAnnotations`) from
+ * `@ingcreators/annot-playwright`. Re-exporting here is
+ * back-compat only and will be removed in
+ * `@ingcreators/annot-product-docs-astro@0.5.0`.
+ */
+export type { AnnotScreenshotOptions, Clip, RebaseResult } from '@ingcreators/annot-playwright';
+/**
+ * @deprecated Import `patchScreenshot` from
+ * `@ingcreators/annot-playwright`. Re-exporting here is
+ * back-compat only and will be removed in
+ * `@ingcreators/annot-product-docs-astro@0.5.0`.
+ */
+export { describeAnnotation, patchScreenshot, rebaseAnnotations, } from '@ingcreators/annot-playwright';
+/**
+ * @deprecated Import `test` from `@ingcreators/annot-product-docs`
+ * (with MDX support) or `@ingcreators/annot-playwright` (without).
+ * Re-exporting here is back-compat only and will be removed in
+ * `@ingcreators/annot-product-docs-astro@0.5.0`.
+ */
+export { test } from '@ingcreators/annot-product-docs';
+/**
+ * @deprecated Import `expect` from `@ingcreators/annot-playwright`
+ * or `@playwright/test` directly. Re-exporting here is back-compat
+ * only and will be removed in
+ * `@ingcreators/annot-product-docs-astro@0.5.0`.
+ */
 export { expect } from '@playwright/test';
-export type { AnnotScreenshotOptions } from './fixture.js';
-export { patchScreenshot, test } from './fixture.js';
-export type { Clip, RebaseResult } from './rebase.js';
-export { describeAnnotation, rebaseAnnotations } from './rebase.js';