@joycostudio/iris 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 JOYCO Studio
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -1,3 +1,138 @@
-# Temporary Holding Version
+# Iris
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Iris turns image sources and usage context into a loading plan. It has three parts:
+
+- **Prepare assets:** Find image files and hardcoded URLs in your code, inspect their metadata, then generate a catalog and small placeholders.
+- **Define a policy:** Recipes describe loading stages. Rules choose a recipe using image metadata and how the image is used.
+- **Render the plan:** The Next.js adapter applies the policy with Next Image. The core policy can also drive other renderers.
+
+Next.js remains responsible for responsive sizes, optimization, and the final image request.
+
+## Get started
+
+Requires Node.js 22.18+, Next.js 16+, and Sharp for image generation.
+
+### 1. Install and initialize
+
+```sh
+npm i @joycostudio/iris
+npm i -D sharp
+npx iris init
+```
+
+### 2. Set up `iris.config.ts`
+
+```ts
+import { createIris } from "@joycostudio/iris"
+
+export default createIris({
+  assets: ["public/images/**/*.{png,jpg,jpeg,webp,avif,gif}"],
+  recipes: {
+    direct: { preview: "none" },
+    blur: { placeholder: "blur" },
+    staged: { placeholder: "blur", preview: { ratio: 0.5 } },
+  },
+  rules: [
+    { when: { priority: true }, recipe: "direct" },
+    { include: "/images/gallery/**", recipe: "staged" },
+  ],
+  fallback: "blur",
+})
+
+export const generate = {
+  output: "src/generated/iris",
+  scan: ["src/**/*.{js,jsx,ts,tsx}", "app/**/*.{js,jsx,ts,tsx}"],
+}
+```
+
+`assets` catalogs files in `public/images`, including images no page uses yet. `scan` finds image URLs already written in your JS/TS files, including JSX like `<Image src="/images/hero.png" />`. The first matching rule chooses a recipe; `fallback` covers everything else.
+
+### 3. Generate and use it
+
+```sh
+npx iris generate
+```
+
+```tsx
+import { IrisImage } from "@/generated/iris/image"
+
+<IrisImage src="/images/hero.png" alt="Hero" fill sizes="100vw" priority />
+<IrisImage src="/images/gallery/photo.jpg" alt="Photo" width={1200} height={800} />
+```
+
+Use regular Next Image props. Run `iris generate` again when image sources or placeholder encoding settings change. An image missing from the catalog renders as ordinary Next Image.
+
+## Recipe and rules
+
+### Recipes
+
+A **recipe** is a named loading behavior. It controls what appears while the final image loads; Next.js still chooses and requests the final image.
+
+| Recipe in the example | Definition                                         | Result                                                  |
+| --------------------- | -------------------------------------------------- | ------------------------------------------------------- |
+| `direct`              | `{ preview: "none" }`                              | Final image, without an Iris preview                    |
+| `blur`                | `{ placeholder: "blur" }`                          | Tiny blurred placeholder, then final image              |
+| `staged`              | `{ placeholder: "blur", preview: { ratio: 0.5 } }` | Placeholder, optional smaller preview, then final image |
+
+Define each recipe under `recipes` and refer to it by name in a rule or `fallback`. A recipe can also be a synchronous function when its behavior depends on the image:
+
+```ts
+recipes: {
+  adaptive: ({ asset, usage }) => ({
+    placeholder: "blur",
+    preview: asset.bytes > 500_000 && !usage.priority ? { ratio: 0.5 } : "none",
+  }),
+}
+```
+
+`placeholder` accepts `"none"`, `"blur"`, or blur settings. `preview` accepts `"none"` or settings such as `ratio`, `maxWidth`, and `quality`.
+
+### Rules
+
+A **rule** says _when_ to use a named recipe. When `IrisImage` renders, Iris tests `rules` using catalog metadata and image props. It checks from top to bottom and uses the first match. If none match, it uses `fallback`. The `recipe` prop on one `IrisImage` overrides this selection.
+
+```ts
+rules: [
+  { when: { priority: true }, recipe: "direct" },
+  {
+    include: "/images/gallery/**",
+    when: { sourceBytes: { min: 500_000 } },
+    recipe: "staged",
+  },
+  { when: ({ asset }) => asset.alpha === true, recipe: "direct" },
+]
+```
+
+Here, a priority gallery image uses `direct` because that rule comes first. A nonpriority gallery image over 500 KB uses `staged`; an image matching no rule uses `fallback`.
+
+Each rule can have `include` and `exclude` filters for the source URL, plus a `when` condition. They must all pass for the rule to match. `when` can be an object of conditions, as above, or a synchronous function. `include` and `exclude` accept strings/globs, regular expressions, functions, and arrays. Recipe callbacks and rule predicates receive the same context:
+
+| Field      | What it contains                                                                            |
+| ---------- | ------------------------------------------------------------------------------------------- |
+| `src`      | The image URL                                                                               |
+| `asset`    | Catalog metadata for the original image, such as `width`, `bytes`, `format`, and `alpha`    |
+| `variants` | Known image variants plus the original                                                      |
+| `usage`    | Render context, such as `width` in CSS pixels, `dpr`, `priority`, `tags`, and `custom` data |
+
+Object conditions include `priority`, `sourceBytes`, `sourceWidth`, `renderedWidth`, `targetWidth`, `format`, and `alpha`. Size conditions use inclusive `{ min?, max? }` ranges. `renderedWidth` comes from `usage.width` (or a fixed `width` prop); `targetWidth` is that width multiplied by `usage.dpr` (default `1`). For a `fill` image, pass `usage={{ width: 800 }}` if a rule needs its rendered width.
+
+## Common project needs
+
+| Need                                                     | Use                                                  |
+| -------------------------------------------------------- | ---------------------------------------------------- |
+| Find hardcoded image URLs in app code                    | `generate.scan`                                      |
+| Include all images in a folder                           | `assets` with a `public/**` glob                     |
+| Skip tests, fixtures, or specific URLs                   | `generate.exclude`                                   |
+| Add CMS or remote image URLs                             | `generate.sources` or an async `generate()` function |
+| Choose a recipe by priority, image size, format, or path | `rules` with `when` or `include`                     |
+| Inspect generated assets and policy results              | `generate.report: true`                              |
+
+`scan` recognizes literal PNG, JPEG, WebP, AVIF, and GIF URLs, including full remote URLs. It cannot evaluate variables, imported assets, or interpolated paths; add those through `assets` or `generate.sources`. Remote images must be reachable when you run `iris generate`. Scanning does not rewrite your code: use `IrisImage` where you want the policy applied.
+
+## Reference
+
+See the [full reference](https://github.com/joyco-studio/iris/blob/main/docs/reference.md) for [configuration options](https://github.com/joyco-studio/iris/blob/main/docs/reference.md#configuration-reference), [loading behavior](https://github.com/joyco-studio/iris/blob/main/docs/reference.md#how-it-works), [other renderers](https://github.com/joyco-studio/iris/blob/main/docs/reference.md#other-renderers), and [debugging](https://github.com/joyco-studio/iris/blob/main/docs/reference.md#debugging).
+
+## Maintainers
+
+See [releasing Iris to npm](https://github.com/joyco-studio/iris/blob/main/docs/releasing.md).

package/dist/browser.cjs

@@ -0,0 +1,466 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/browser/index.ts
+var browser_exports = {};
+__export(browser_exports, {
+  createIrisDebugger: () => createIrisDebugger,
+  diagnoseRuntime: () => diagnoseRuntime,
+  inspectImageElement: () => inspectImageElement
+});
+module.exports = __toCommonJS(browser_exports);
+function inspectImageElement(image, manifest = {}, lcpElements = /* @__PURE__ */ new Set(), timing = null) {
+  const rect = image.getBoundingClientRect();
+  const renderedWidth = image.clientWidth || rect.width;
+  const renderedHeight = image.clientHeight || rect.height;
+  const id = image.dataset.iris || image.currentSrc || image.src;
+  const source = manifest[image.dataset.irisSrc || id] ?? manifest[id] ?? manifest[image.currentSrc] ?? manifest[image.src] ?? null;
+  const candidates = parseSrcSet(image.srcset, renderedWidth);
+  const selectedUrl = image.currentSrc || image.src;
+  const selectedWidth = selectedCandidateWidth(selectedUrl, candidates);
+  const dpr = window.devicePixelRatio || 1;
+  const idealWidth = Math.ceil(renderedWidth * dpr);
+  const declaredSlotWidth = resolveSizes(image.sizes);
+  const resource = resourceTiming(selectedUrl);
+  const diagnostics = diagnoseRuntime({
+    source,
+    renderedWidth,
+    renderedHeight,
+    visualWidth: rect.width,
+    visualHeight: rect.height,
+    idealWidth,
+    selectedWidth,
+    availableWidths: candidates.map((candidate) => candidate.width),
+    declaredSlotWidth,
+    objectFit: getComputedStyle(image).objectFit
+  });
+  return {
+    id,
+    source,
+    renderedWidth,
+    renderedHeight,
+    visualWidth: rect.width,
+    visualHeight: rect.height,
+    naturalWidth: image.naturalWidth,
+    dpr,
+    idealWidth,
+    selectedWidth,
+    selectedUrl,
+    availableWidths: candidates.map((candidate) => candidate.width),
+    declaredSizes: image.sizes,
+    declaredSlotWidth,
+    loading: image.loading,
+    objectFit: getComputedStyle(image).objectFit,
+    transferBytes: resource?.transferSize ?? null,
+    duration: resource?.duration ?? null,
+    timing,
+    isLcp: lcpElements.has(image),
+    diagnostics
+  };
+}
+function createIrisDebugger(options = {}) {
+  const reports = /* @__PURE__ */ new Map();
+  const lcpElements = /* @__PURE__ */ new Set();
+  let mutationObserver = null;
+  let resizeObserver = null;
+  let performanceObserver = null;
+  let frame = 0;
+  let tableTimer = null;
+  let lastTableSignature = "";
+  const pending = /* @__PURE__ */ new Set();
+  const timelines = /* @__PURE__ */ new WeakMap();
+  const selector = options.scope === "document" ? "img" : "img[data-iris]";
+  const measure = (image) => {
+    const report2 = inspectImageElement(
+      image,
+      options.manifest,
+      lcpElements,
+      timelines.get(image) ?? null
+    );
+    reports.set(image, report2);
+    scheduleTable();
+  };
+  const table = () => logReportTable(report(), options.console ?? "warnings");
+  const scheduleTable = () => {
+    if (options.console === "silent") return;
+    if (tableTimer) clearTimeout(tableTimer);
+    tableTimer = setTimeout(() => {
+      tableTimer = null;
+      const signature = reportSignature(report());
+      if (signature === lastTableSignature) return;
+      lastTableSignature = signature;
+      table();
+    }, 250);
+  };
+  const schedule = (image) => {
+    pending.add(image);
+    if (frame) return;
+    frame = requestAnimationFrame(() => {
+      frame = 0;
+      for (const pendingImage of pending) measure(pendingImage);
+      pending.clear();
+    });
+  };
+  const observe = (root = document) => {
+    resizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        if (entry.target instanceof HTMLImageElement) schedule(entry.target);
+      }
+    });
+    const register = (image) => {
+      resizeObserver?.observe(image);
+      image.addEventListener("load", () => schedule(image), { once: true });
+      if (image.complete) schedule(image);
+    };
+    root.querySelectorAll(selector).forEach(register);
+    mutationObserver = new MutationObserver((records) => {
+      for (const record of records) {
+        for (const node of record.addedNodes) {
+          if (!(node instanceof Element)) continue;
+          if (node.matches(selector)) register(node);
+          node.querySelectorAll(selector).forEach(register);
+        }
+      }
+    });
+    mutationObserver.observe(root, { childList: true, subtree: true });
+    if (typeof PerformanceObserver !== "undefined") {
+      performanceObserver = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          const element = entry.element;
+          if (element) {
+            lcpElements.add(element);
+            if (element instanceof HTMLImageElement) schedule(element);
+          }
+        }
+      });
+      try {
+        performanceObserver.observe({
+          type: "largest-contentful-paint",
+          buffered: true
+        });
+      } catch {
+        performanceObserver = null;
+      }
+    }
+    return api;
+  };
+  const disconnect = () => {
+    mutationObserver?.disconnect();
+    resizeObserver?.disconnect();
+    performanceObserver?.disconnect();
+    cancelAnimationFrame(frame);
+    if (tableTimer) clearTimeout(tableTimer);
+    tableTimer = null;
+    frame = 0;
+    pending.clear();
+  };
+  const report = () => [...reports.values()];
+  const startTimeline = (image) => {
+    timelines.set(image, {
+      blurMs: null,
+      previewMs: null,
+      finalMs: null,
+      startedAt: null,
+      previewAt: null,
+      finalAt: null
+    });
+  };
+  const markPreview = (image, preview, at = performance.now()) => {
+    const timing = timelines.get(image);
+    if (!timing) return;
+    timing.startedAt = resourceTiming(preview.currentSrc || preview.src)?.startTime ?? at;
+    timing.previewAt = at;
+    timing.blurMs = roundDuration(at - timing.startedAt);
+    schedule(image);
+  };
+  const markFinal = (image, at = performance.now()) => {
+    const timing = timelines.get(image);
+    if (!timing) return;
+    const finalStartedAt = resourceTiming(image.currentSrc || image.src)?.startTime ?? at;
+    timing.finalAt = at;
+    timing.finalMs = roundDuration(at - finalStartedAt);
+    if (timing.previewAt === null) {
+      timing.startedAt = finalStartedAt;
+      timing.blurMs = timing.finalMs;
+    } else timing.previewMs = roundDuration(at - timing.previewAt);
+    schedule(image);
+  };
+  const summary = () => ({
+    inspected: reports.size,
+    healthy: report().filter((item) => item.diagnostics.length === 0).length,
+    warnings: report().flatMap((item) => item.diagnostics).filter((item) => item.severity === "warning").length,
+    errors: report().flatMap((item) => item.diagnostics).filter((item) => item.severity === "error").length
+  });
+  const api = {
+    observe,
+    disconnect,
+    report,
+    table,
+    summary,
+    startTimeline,
+    markPreview,
+    markFinal
+  };
+  return api;
+}
+function roundDuration(value) {
+  return Math.round(value * 10) / 10;
+}
+function resourceTiming(url) {
+  const normalized = normalizeUrl(url);
+  const entries = performance.getEntriesByType(
+    "resource"
+  );
+  for (let index = entries.length - 1; index >= 0; index--) {
+    if (normalizeUrl(entries[index].name) === normalized) return entries[index];
+  }
+  return void 0;
+}
+function parseSrcSet(srcset, renderedWidth) {
+  return srcset.split(",").map((value) => value.trim().split(/\s+/)).map(([url, descriptor]) => ({
+    url,
+    width: descriptor?.endsWith("w") ? Number.parseInt(descriptor, 10) : descriptor?.endsWith("x") ? Math.round(Number.parseFloat(descriptor) * renderedWidth) : 0
+  })).filter((candidate) => candidate.url && candidate.width > 0);
+}
+function selectedCandidateWidth(selectedUrl, candidates) {
+  const selected = normalizeUrl(selectedUrl);
+  const candidate = candidates.find(
+    (item) => normalizeUrl(item.url) === selected
+  );
+  if (candidate) return candidate.width;
+  const queryWidth = new URL(
+    selectedUrl,
+    window.location.href
+  ).searchParams.get("w");
+  return queryWidth ? Number(queryWidth) : null;
+}
+function normalizeUrl(url) {
+  try {
+    return new URL(url, window.location.href).href;
+  } catch {
+    return url;
+  }
+}
+function diagnoseRuntime(input) {
+  const diagnostics = [];
+  if (input.visualWidth !== void 0 && input.renderedWidth > 0 && Math.abs(input.visualWidth - input.renderedWidth) / input.renderedWidth > 0.02) {
+    diagnostics.push(
+      runtimeDiagnostic(
+        "css-transform-affects-visual-size",
+        "info",
+        "high",
+        "A CSS transform changes the visual width; responsive selection still uses the untransformed layout slot.",
+        {
+          renderedWidth: input.renderedWidth,
+          visualWidth: input.visualWidth
+        }
+      )
+    );
+  }
+  if (input.declaredSlotWidth && input.renderedWidth > 0) {
+    const pixelDifference = input.declaredSlotWidth - input.renderedWidth;
+    const difference = pixelDifference / input.renderedWidth;
+    const isMaterialMismatch = Math.abs(pixelDifference) >= 32;
+    if (difference < -0.1 && isMaterialMismatch) {
+      diagnostics.push(
+        runtimeDiagnostic(
+          "sizes-understates-layout",
+          "warning",
+          "high",
+          "The active sizes slot is smaller than the rendered CSS width.",
+          {
+            declaredSlotWidth: input.declaredSlotWidth,
+            renderedWidth: input.renderedWidth,
+            pixelDifference,
+            difference
+          }
+        )
+      );
+    } else if (difference > 0.25 && isMaterialMismatch) {
+      diagnostics.push(
+        runtimeDiagnostic(
+          "sizes-overstates-layout",
+          "warning",
+          "high",
+          "The active sizes slot is substantially larger than the rendered CSS width.",
+          {
+            declaredSlotWidth: input.declaredSlotWidth,
+            renderedWidth: input.renderedWidth,
+            pixelDifference,
+            difference
+          }
+        )
+      );
+    }
+  }
+  if (input.source && input.source.width < input.idealWidth) {
+    diagnostics.push(
+      runtimeDiagnostic(
+        "source-too-small",
+        "error",
+        "high",
+        "The source is smaller than the rendered width \xD7 DPR target.",
+        {
+          sourceWidth: input.source.width,
+          idealWidth: input.idealWidth
+        }
+      )
+    );
+  }
+  if (input.selectedWidth && input.selectedWidth < input.idealWidth) {
+    const hasLarger = input.availableWidths.some(
+      (width) => width >= input.idealWidth
+    );
+    diagnostics.push(
+      runtimeDiagnostic(
+        hasLarger ? "browser-downselected" : "missing-useful-candidate",
+        hasLarger ? "info" : "warning",
+        "high",
+        hasLarger ? "The browser selected below the theoretical target although a larger candidate exists." : "No available candidate reaches the theoretical target.",
+        { selectedWidth: input.selectedWidth, idealWidth: input.idealWidth }
+      )
+    );
+  }
+  if (input.source && input.objectFit === "cover") {
+    const sourceRatio = input.source.width / input.source.height;
+    const renderedRatio = input.renderedWidth / input.renderedHeight;
+    if (Math.abs(sourceRatio - renderedRatio) / sourceRatio > 0.02) {
+      diagnostics.push(
+        runtimeDiagnostic(
+          "cropped-image",
+          "info",
+          "high",
+          "object-fit: cover crops part of the downloaded source.",
+          {
+            sourceAspectRatio: sourceRatio,
+            renderedAspectRatio: renderedRatio
+          }
+        )
+      );
+    }
+  }
+  return diagnostics;
+}
+function resolveSizes(sizes) {
+  if (!sizes || sizes.trim() === "auto") return null;
+  for (const rule of splitTopLevel(sizes)) {
+    const value = rule.trim();
+    let length = value;
+    if (value.startsWith("(")) {
+      const end = matchingParenthesis(value);
+      if (end < 0) continue;
+      if (!matchMedia(value.slice(0, end + 1)).matches) continue;
+      length = value.slice(end + 1).trim();
+    }
+    if (!length || length === "auto") continue;
+    const probe = document.createElement("div");
+    probe.style.cssText = `position:fixed;visibility:hidden;pointer-events:none;width:${length};height:0`;
+    document.body.append(probe);
+    const width = probe.getBoundingClientRect().width;
+    probe.remove();
+    return Number.isFinite(width) && width > 0 ? width : null;
+  }
+  return null;
+}
+function splitTopLevel(value) {
+  const output = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < value.length; index++) {
+    if (value[index] === "(") depth++;
+    if (value[index] === ")") depth--;
+    if (value[index] === "," && depth === 0) {
+      output.push(value.slice(start, index));
+      start = index + 1;
+    }
+  }
+  output.push(value.slice(start));
+  return output;
+}
+function matchingParenthesis(value) {
+  let depth = 0;
+  for (let index = 0; index < value.length; index++) {
+    if (value[index] === "(") depth++;
+    if (value[index] === ")" && --depth === 0) return index;
+  }
+  return -1;
+}
+function runtimeDiagnostic(code, severity, confidence, message, evidence) {
+  return { code, severity, confidence, message, evidence };
+}
+function logReportTable(reports, mode) {
+  if (mode === "silent") return;
+  const visible = reports.filter(
+    (report) => mode === "all" || report.diagnostics.some((diagnostic) => diagnostic.severity !== "info")
+  );
+  if (visible.length === 0) return;
+  console.table(
+    visible.map((report) => ({
+      asset: report.id,
+      stage: imageStage(report),
+      rendered: `${Math.round(report.renderedWidth)}\xD7${Math.round(report.renderedHeight)}`,
+      selected: report.selectedWidth,
+      ideal: report.idealWidth,
+      bytes: report.transferBytes,
+      blurMs: report.timing?.blurMs ?? null,
+      previewMs: report.timing?.previewMs ?? null,
+      finalMs: report.timing?.finalMs ?? null,
+      lazy: report.loading === "lazy",
+      lcp: report.isLcp,
+      status: diagnosticStatus(report),
+      diagnostics: report.diagnostics.map((diagnostic) => diagnostic.code).join(", ")
+    }))
+  );
+}
+function imageStage(report) {
+  if (report.timing?.finalAt !== null && report.timing?.finalAt !== void 0)
+    return "final";
+  if (report.timing?.previewAt) return "preview";
+  if (report.timing) return "blur";
+  return report.naturalWidth > 0 ? "final" : "loading";
+}
+function diagnosticStatus(report) {
+  if (report.diagnostics.some((item) => item.severity === "error"))
+    return "error";
+  if (report.diagnostics.some((item) => item.severity === "warning"))
+    return "warning";
+  if (report.diagnostics.some((item) => item.severity === "info")) return "info";
+  return "healthy";
+}
+function reportSignature(reports) {
+  return reports.map(
+    (report) => [
+      report.id,
+      imageStage(report),
+      report.selectedWidth,
+      report.transferBytes,
+      report.timing?.blurMs,
+      report.timing?.previewMs,
+      report.timing?.finalMs,
+      diagnosticStatus(report)
+    ].join(":")
+  ).join("|");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createIrisDebugger,
+  diagnoseRuntime,
+  inspectImageElement
+});
+//# sourceMappingURL=browser.cjs.map