@ingcreators/annot-product-docs-astro 0.1.0 → 0.2.1

package/dist/components/TransitionTable.astro

@@ -0,0 +1,55 @@
+---
+// `<TransitionTable>` — tabular list of every `<Transition>`
+// on the page. Pass an array of transition descriptors as the
+// `entries` prop; the table renders them with one row per
+// transition. The reader sees "trigger / event / target" as
+// columns plus a body cell with the prose.
+//
+// MDX usage:
+//   <TransitionTable
+//     entries={[
+//       { trigger: "Sign in", on: "click", to: "dashboard", body: "..." },
+//       { trigger: "Sign up", on: "click", to: "signup", body: "..." },
+//     ]}
+//   />
+//
+// The companion `<Transition>` component is the inline variant
+// for free-flowing prose. Both compile to data attributes the
+// reader CSS can style consistently.
+
+export interface TransitionEntry {
+  trigger: string;
+  on?: string;
+  to?: string;
+  body?: string;
+}
+
+interface Props {
+  entries: TransitionEntry[];
+}
+const { entries } = Astro.props;
+---
+<table class="annot-transition-table">
+  <thead>
+    <tr>
+      <th>Trigger</th>
+      <th>Event</th>
+      <th>Target</th>
+      <th>Notes</th>
+    </tr>
+  </thead>
+  <tbody>
+    {entries.map((entry) => (
+      <tr
+        data-trigger={entry.trigger}
+        data-on={entry.on}
+        data-to={entry.to}
+      >
+        <td>{entry.trigger}</td>
+        <td>{entry.on ?? "—"}</td>
+        <td>{entry.to ?? "—"}</td>
+        <td set:html={entry.body ?? ""} />
+      </tr>
+    ))}
+  </tbody>
+</table>

package/dist/components/types.d.ts

@@ -0,0 +1,21 @@
+import { MatchKey } from '@ingcreators/annot-product-docs';
+export type Match = MatchKey;
+export type OverlayIntent = "info" | "warning" | "error" | "success" | "neutral" | "required" | "action";
+export interface TransitionEntry {
+    trigger: string;
+    on?: string;
+    to?: string;
+    body?: string;
+}
+export interface ScreenListEntry {
+    id: string;
+    title?: string;
+    href?: string;
+    order?: number;
+}
+export interface GraphEdge {
+    from: string;
+    to: string;
+    label?: string;
+}
+export type GraphDirection = "TB" | "LR" | "BT" | "RL";

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+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 { RenderAnnotatedScreenOptions, RenderResult, } from './render.js';
+export { parseSnapshotBoxes, renderAnnotatedScreen, resolveMdxAnnotations, svgFromBboxAnnotations, } from './render.js';

package/dist/index.js

@@ -0,0 +1,18 @@
+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 = {}) {
+	let t = {
+		contentDir: e.contentDir ?? "docs",
+		configPath: e.configPath ?? "annot-docs.config.ts",
+		verbose: e.verbose ?? !1
+	};
+	return {
+		name: c,
+		hooks: { "astro:config:setup": ({ logger: e }) => {
+			t.verbose && e.info(`${c} installed — contentDir=${t.contentDir} configPath=${t.configPath}`);
+		} }
+	};
+}
+//#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 };

package/dist/integration.d.ts

@@ -0,0 +1,46 @@
+import { AstroIntegration } from 'astro';
+export interface ProductDocsIntegrationOptions {
+    /**
+     * Directory (relative to the Astro project root) that contains
+     * the `annot:`-frontmatter MDX files the integration should
+     * walk for the Image Service + component-config defaults.
+     * Default: `"docs"`.
+     */
+    contentDir?: string;
+    /**
+     * Path to the `annot-docs.config.ts` config file. Default:
+     * `"annot-docs.config.ts"`. Future PRs read this for the
+     * `meta` defaults + per-book template lookups.
+     */
+    configPath?: string;
+    /**
+     * If `true`, the integration logs a debug line on every
+     * config:setup. Useful for verifying the integration is
+     * installed correctly in an Astro project. Default: `false`.
+     */
+    verbose?: boolean;
+}
+/**
+ * Astro integration factory. Drop into `astro.config.mjs`:
+ *
+ * ```js
+ * import { defineConfig } from "astro/config";
+ * import { productDocsIntegration } from "@ingcreators/annot-product-docs-astro";
+ *
+ * export default defineConfig({
+ *   integrations: [productDocsIntegration()],
+ * });
+ * ```
+ *
+ * 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/fixture.d.ts

@@ -0,0 +1,72 @@
+import { BboxAnnotation } from '@ingcreators/annot-annotator';
+/**
+ * Compositional options for `page.screenshot({ annot })` /
+ * `locator.screenshot({ annot })`. Each field is an independent
+ * contribution to the embedded XMP record:
+ *
+ * - `mdx`     — refresh + resolve MDX `<Overlay>` annotations
+ * - `overlays`— inline `BboxAnnotation[]` (the DSL accepted by
+ *               `@ingcreators/annot-annotator`)
+ * - `tags`    — provenance metadata written verbatim into the XMP
+ * - `editable`— bake-vs-preserve toggle (default `true`)
+ *
+ * `annot: true` / `annot: {}` is treated as a no-op shorthand — the
+ * fixture detects no contribution and the screenshot falls through
+ * to vanilla Playwright behaviour.
+ */
+export interface AnnotScreenshotOptions {
+    /** Refresh the MDX `annot:snapshot` block and resolve the
+     *  `<Screen id>`'s overlays. The MDX file is rewritten in-place
+     *  with the current page's aria-snapshot before overlays resolve.
+     */
+    mdx?: {
+        id: string;
+        path: string;
+    };
+    /** Caller-supplied annotations — merged with MDX-derived ones if
+     *  `mdx` is also set. Same DSL `@ingcreators/annot-annotator`
+     *  accepts. */
+    overlays?: BboxAnnotation[];
+    /** Provenance metadata written verbatim into the PNG's XMP. The
+     *  fixture adds no defaults; callers who want `WELL_KNOWN_TAG_KEYS`
+     *  (`source` / `screen` / `capturedAt` / `commit`) write them. */
+    tags?: Record<string, string>;
+    /** When `true` (default): annotations stored as SVG in XMP +
+     *  original capture embedded → re-editable in Annot Cloud. When
+     *  `false`: annotations baked into the visible pixels, no XMP
+     *  layer, no embedded original — flat PNG, no round-trip. */
+    editable?: boolean;
+}
+declare module "@playwright/test" {
+    interface PageScreenshotOptions {
+        annot?: AnnotScreenshotOptions;
+    }
+    interface LocatorScreenshotOptions {
+        annot?: AnnotScreenshotOptions;
+    }
+}
+/**
+ * Idempotent prototype patch — wrap `screenshot` to intercept the
+ * `annot` opt while falling through to the original method when
+ * absent / empty. Exported for unit tests; production usage flows
+ * through the fixture `extend({ page })` body which calls this once
+ * per worker on the first page (and once for the locator prototype).
+ */
+export declare function patchScreenshot(proto: {
+    screenshot: (opts?: unknown) => Promise<Buffer>;
+}): void;
+/**
+ * `test = base.extend({ page })` — drop-in for `@playwright/test`'s
+ * `test` plus a one-time patch of `Page.prototype.screenshot` AND
+ * `Locator.prototype.screenshot` (per worker process) so calls
+ * carrying `annot: { ... }` run the annot pipeline above.
+ *
+ * The base `test` is `@ingcreators/annot-product-docs`'s test which
+ * already extends `@ingcreators/annot-playwright` — callers get
+ * `page` + `annotator` + `screen` plus the annot-aware screenshot.
+ */
+export declare const test: import('@playwright/test').TestType<import('@playwright/test').PlaywrightTestArgs & import('@playwright/test').PlaywrightTestOptions & {
+    annotator: import('@ingcreators/annot-playwright').PlaywrightAnnotator;
+} & {
+    screen: import('@ingcreators/annot-product-docs').Screen;
+}, import('@playwright/test').PlaywrightWorkerArgs & import('@playwright/test').PlaywrightWorkerOptions>;

package/dist/playwright/index.d.ts

@@ -0,0 +1,5 @@
+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';

package/dist/playwright/index.js

@@ -0,0 +1,225 @@
+import { i as e, r as t } from "../render-BSQOeqPB.js";
+import { writeFile as n } from "node:fs/promises";
+import { createAnnotator as r } from "@ingcreators/annot-annotator";
+import { captureScreen as i, test as a } from "@ingcreators/annot-product-docs";
+import { expect as o } from "@playwright/test";
+import { writePngWithTagsOnly as s } from "@ingcreators/annot-core/xmp-bytes";
+//#region src/playwright/rebase.ts
+function c(e, t) {
+	let n = [], r = [];
+	for (let i of e) {
+		let e = l(i, t);
+		e ? n.push(e) : r.push(i);
+	}
+	return {
+		kept: n,
+		dropped: r
+	};
+}
+function l(e, t) {
+	switch (e.type) {
+		case "rect": return u(e, t);
+		case "numberedBadge": return d(e, t);
+		case "callout": return f(e, t);
+		case "circle": return p(e, t);
+		case "arrow": return m(e, t);
+		case "text": return h(e, t);
+		case "raw": return g(e);
+	}
+}
+function u(e, t) {
+	return y(e.bbox, t) ? {
+		...e,
+		bbox: _(e.bbox, t)
+	} : null;
+}
+function d(e, t) {
+	return y(e.bbox, t) ? {
+		...e,
+		bbox: _(e.bbox, t),
+		imageWidth: t.width,
+		imageHeight: t.height
+	} : null;
+}
+function f(e, t) {
+	return !y(e.targetBbox, t) || !b(e.at, t) ? null : {
+		...e,
+		at: v(e.at, t),
+		targetBbox: _(e.targetBbox, t)
+	};
+}
+function p(e, t) {
+	return y({
+		x: e.center.x - e.radius,
+		y: e.center.y - e.radius,
+		width: e.radius * 2,
+		height: e.radius * 2
+	}, t) ? {
+		...e,
+		center: v(e.center, t)
+	} : null;
+}
+function m(e, t) {
+	return !b(e.from, t) || !b(e.to, t) ? null : {
+		...e,
+		from: v(e.from, t),
+		to: v(e.to, t)
+	};
+}
+function h(e, t) {
+	return b(e.at, t) ? {
+		...e,
+		at: v(e.at, t)
+	} : null;
+}
+function g(e) {
+	return e;
+}
+function _(e, t) {
+	return {
+		x: e.x - t.x,
+		y: e.y - t.y,
+		width: e.width,
+		height: e.height
+	};
+}
+function v(e, t) {
+	return {
+		x: e.x - t.x,
+		y: e.y - t.y
+	};
+}
+function y(e, t) {
+	return e.x >= t.x && e.y >= t.y && e.x + e.width <= t.x + t.width && e.y + e.height <= t.y + t.height;
+}
+function b(e, t) {
+	return e.x >= t.x && e.y >= t.y && e.x <= t.x + t.width && e.y <= t.y + t.height;
+}
+function x(e) {
+	switch (e.type) {
+		case "rect":
+		case "numberedBadge": return `${e.type}@(${e.bbox.x},${e.bbox.y},${e.bbox.width},${e.bbox.height})`;
+		case "callout": return `callout@(${e.targetBbox.x},${e.targetBbox.y},${e.targetBbox.width},${e.targetBbox.height})`;
+		case "circle": return `circle@(${e.center.x},${e.center.y},r=${e.radius})`;
+		case "arrow": return `arrow@(${e.from.x},${e.from.y})→(${e.to.x},${e.to.y})`;
+		case "text": return `text@(${e.at.x},${e.at.y})`;
+		case "raw": return "raw[<svg fragment>]";
+	}
+}
+//#endregion
+//#region src/playwright/fixture.ts
+var S = Symbol.for("@ingcreators/annot:screenshot-patched");
+function C(e) {
+	let t = e;
+	if (t[S]) return;
+	let n = e.screenshot;
+	e.screenshot = async function(e = {}) {
+		let t = e?.annot;
+		return w(t) ? D.call(this, n, e) : n.call(this, e);
+	}, t[S] = !0;
+}
+function w(e) {
+	return !e || e === !0 ? !1 : !!(e.mdx || e.overlays && e.overlays.length > 0 || e.tags);
+}
+function T(e) {
+	return typeof e.boundingBox == "function";
+}
+function E(e) {
+	return T(e) ? e.page() : e;
+}
+async function D(e, t) {
+	let { annot: r, path: a, ...o } = t, s = o, c = r.editable ?? !0;
+	r.mdx && await i(E(this), {
+		id: r.mdx.id,
+		mdxPath: r.mdx.path
+	});
+	let l = await O(this, t.clip), u = await A({
+		rawBytes: k(await e.call(this, {
+			...s,
+			path: void 0
+		})),
+		annot: r,
+		editable: c,
+		clip: l
+	});
+	return a && await n(a, u), Buffer.from(u);
+}
+async function O(e, t) {
+	if (T(e)) {
+		let t = await e.boundingBox();
+		if (!t) throw Error("locator.screenshot({ annot }): locator has no bounding box (probably not visible). Re-test with a stable selector / waitFor().");
+		return t;
+	}
+	return t ?? null;
+}
+function k(e) {
+	return e instanceof Uint8Array && !(e instanceof Buffer) ? e : new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+}
+async function A(n) {
+	let { rawBytes: i, annot: a, editable: o, clip: l } = n, u = N(i), d = [];
+	if (a.mdx) {
+		let e = l ? {
+			width: l.x + l.width,
+			height: l.y + l.height
+		} : u, n = await t({
+			mdxPath: a.mdx.path,
+			screenId: a.mdx.id,
+			dims: e
+		});
+		d.push(...n);
+	}
+	a.overlays && d.push(...a.overlays);
+	let f;
+	if (l) {
+		let { kept: e, dropped: t } = c(d, l);
+		f = e, t.length > 0 && j(t);
+	} else f = d;
+	let p = !!(a.mdx || a.overlays);
+	if (p && !o) {
+		let t = e(f), n = `data:image/png;base64,${Buffer.from(i).toString("base64")}`, o = r({ loadSystemFonts: !0 }).toPng({
+			originalDataUrl: n,
+			annotationsSvg: t,
+			width: u.width,
+			height: u.height
+		});
+		return a.tags ? s(o, a.tags) : o;
+	}
+	if (p) {
+		let t = e(f), n = `data:image/png;base64,${Buffer.from(i).toString("base64")}`;
+		return r({ loadSystemFonts: !0 }).toEditablePng({
+			originalDataUrl: n,
+			annotationsSvg: t,
+			width: u.width,
+			height: u.height,
+			tags: a.tags
+		});
+	}
+	return a.tags ? s(i, a.tags) : i;
+}
+function j(e) {
+	let t = e.map(x).join(", "), n = `annot fixture: dropped ${e.length} overlay(s) outside the screenshot clip — ${t}`;
+	console.warn(n), M(n, e);
+}
+function M(e, t) {
+	try {
+		let n = a.info?.();
+		if (!n?.annotations) return;
+		n.annotations.push({
+			type: "warning",
+			description: `${e} (${t.length} dropped)`
+		});
+	} catch {}
+}
+function N(e) {
+	if (e.length < 24) throw Error("Playwright annot fixture: raw screenshot too short to contain PNG IHDR.");
+	let t = new DataView(e.buffer, e.byteOffset, e.byteLength);
+	return {
+		width: t.getUint32(16, !1),
+		height: t.getUint32(20, !1)
+	};
+}
+var P = a.extend({ page: async ({ page: e }, t) => {
+	C(Object.getPrototypeOf(e)), C(Object.getPrototypeOf(e.locator("html"))), await t(e);
+} });
+//#endregion
+export { x as describeAnnotation, o as expect, C as patchScreenshot, c as rebaseAnnotations, P as test };

package/dist/playwright/rebase.d.ts

@@ -0,0 +1,36 @@
+import { BboxAnnotation } from '@ingcreators/annot-annotator';
+export interface Clip {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface RebaseResult {
+    /** Annotations whose coordinates were rebased into clip-space. */
+    kept: BboxAnnotation[];
+    /** Annotations that fell outside `clip` and were dropped. The
+     *  caller surfaces these as `RenderResult.droppedOverlays` /
+     *  `test.info().annotations` warnings. */
+    dropped: BboxAnnotation[];
+}
+/**
+ * Rebase + filter a `BboxAnnotation[]` against a clip rectangle.
+ *
+ * - `kept` = annotations whose visible coords were translated by
+ *   `(-clip.x, -clip.y)`. The new coords are in the clipped image's
+ *   coordinate space (0,0 at the top-left of the screenshot).
+ * - `dropped` = annotations whose bbox / endpoints fell outside the
+ *   clip. Returned verbatim (un-rebased) so the caller can log
+ *   which originals were skipped.
+ *
+ * `numberedBadge`'s `imageWidth` / `imageHeight` are also rebased
+ * to match the clip dimensions, so `placement: "auto"` picks the
+ * corner against the cropped image edge rather than the page edge.
+ */
+export declare function rebaseAnnotations(annotations: BboxAnnotation[], clip: Clip): RebaseResult;
+/**
+ * Format a short identifier for an annotation so dropped diagnostics
+ * stay readable. We don't have a stable id field on the DSL types —
+ * use `type` + first bbox coords as a heuristic.
+ */
+export declare function describeAnnotation(ann: BboxAnnotation): string;

package/dist/render-BSQOeqPB.js

@@ -0,0 +1,164 @@
+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 { bboxAnnotationsToSvg as c, createAnnotator as l } from "@ingcreators/annot-annotator";
+import { parseMdxFile as u } from "@ingcreators/annot-product-docs";
+//#region src/cache.ts
+var d = 1;
+function f(t) {
+	let n = e("sha256");
+	return n.update("v1\n"), n.update(t.mdxSource), n.update("\0"), n.update(t.screenId), t.editable && n.update("\0editable"), n.digest("hex");
+}
+function p(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 m() {
+	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/render.ts
+async function h(e) {
+	let t = e.cwd ?? process.cwd(), n = a(e.mdxPath) ? e.mdxPath : s(t, e.mdxPath), r = await u(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 c = g(e.editable), d = f({
+		mdxSource: r.source,
+		screenId: e.screenId,
+		editable: c !== null
+	});
+	if (e.cache) {
+		let t = await e.cache.get(d);
+		if (t) return {
+			bytes: t,
+			fromCache: !0,
+			hadBoundingBoxes: !0
+		};
+	}
+	let p = e.basePngBytes ?? await C(r, o.src, i(n)), m = w(p), h = v(r.commentBlocks.snapshot ?? ""), y = b(o.overlays, h, m), S, T;
+	if (y.length === 0) if (T = !1, c !== null) {
+		let e = `data:image/png;base64,${Buffer.from(p).toString("base64")}`;
+		S = l({ loadSystemFonts: !0 }).toEditablePng({
+			originalDataUrl: e,
+			annotationsSvg: _(),
+			width: m.width,
+			height: m.height,
+			tags: c.tags
+		});
+	} else S = p;
+	else {
+		let e = `data:image/png;base64,${Buffer.from(p).toString("base64")}`, t = x(y), n = l({ loadSystemFonts: !0 }), r = {
+			originalDataUrl: e,
+			annotationsSvg: t,
+			width: m.width,
+			height: m.height
+		};
+		S = c === null ? n.toPng(r) : n.toEditablePng({
+			...r,
+			tags: c.tags
+		}), T = !0;
+	}
+	return e.cache && await e.cache.set(d, S), {
+		bytes: S,
+		fromCache: !1,
+		hadBoundingBoxes: T
+	};
+}
+function g(e) {
+	return e ? e === !0 ? {} : e : null;
+}
+function _() {
+	return "<svg xmlns=\"http://www.w3.org/2000/svg\"></svg>";
+}
+function v(e) {
+	let t = [];
+	for (let n of e.split(/\r?\n/)) {
+		if (!n.trim()) continue;
+		let e = n.match(/^\s*-\s+([a-z]+)(?:\s+"([^"]*?)")?/);
+		if (!e) continue;
+		let r = e[1] ?? "", i = e[2] ?? "", a = n.match(/\[ref=(e\d+)\]/)?.[1], o = n.match(/\[box=(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?)\]/);
+		!a || !o || t.push({
+			role: r,
+			name: i,
+			ref: a,
+			box: {
+				x: Number.parseFloat(o[1]),
+				y: Number.parseFloat(o[2]),
+				width: Number.parseFloat(o[3]),
+				height: Number.parseFloat(o[4])
+			}
+		});
+	}
+	return t;
+}
+async function y(e) {
+	let t = e.cwd ?? process.cwd(), n = await u(a(e.mdxPath) ? e.mdxPath : s(t, e.mdxPath));
+	if (!n) throw Error(`resolveMdxAnnotations: ${e.mdxPath} has no \`annot:\` frontmatter — cannot resolve.`);
+	let r = n.screens.find((t) => t.id === e.screenId);
+	if (!r) throw Error(`resolveMdxAnnotations: ${e.mdxPath} has no <Screen id="${e.screenId}"> block.`);
+	let i = v(n.commentBlocks.snapshot ?? "");
+	return b(r.overlays, i, e.dims);
+}
+function b(e, t, n) {
+	let r = [], i = 1;
+	for (let a of e) {
+		let e = t.find((e) => e.role === a.match.role && e.name === a.match.name);
+		if (!e) continue;
+		let o = a.number ?? i++;
+		r.push({
+			type: "numberedBadge",
+			bbox: e.box,
+			number: o,
+			placement: "auto",
+			imageWidth: n.width,
+			imageHeight: n.height,
+			intent: a.intent === "action" ? "warning" : a.intent === "required" ? "error" : "info"
+		});
+	}
+	return r;
+}
+function x(e) {
+	return `<svg xmlns="http://www.w3.org/2000/svg">${c(e)}</svg>`;
+}
+function S(e) {
+	return e.length === 0 ? "<svg xmlns=\"http://www.w3.org/2000/svg\"></svg>" : `<svg xmlns="http://www.w3.org/2000/svg">${c(e)}</svg>`;
+}
+async function C(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 w(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 { d as a, m as c, S as i, h as n, f as o, y as r, p as s, v as t };