@graphrefly/ts 0.0.0 → 0.0.1

package/dist/chunk-YXMZ2N6J.js

@@ -0,0 +1,1884 @@
+import {
+  Node
+} from "./chunk-XKXWK2KP.js";
+import {
+  depLatest
+} from "./chunk-WQIA3GFB.js";
+import {
+  errorPayload
+} from "./chunk-S6HXABGL.js";
+
+// src/solutions/reactive-layout/index.ts
+var TEXT_SEGMENTS_MEASUREMENT_KIND = "text-segments";
+var BLOCKS_MEASUREMENT_KIND = "blocks";
+var READINESS_MEASUREMENT_KIND = "readiness";
+var IMAGE_SIZE_MEASUREMENT_KIND = "image-size";
+var SVG_BOUNDS_MEASUREMENT_KIND = "svg-bounds";
+var kinsokuStart = /* @__PURE__ */ new Set([
+  "\u3001",
+  "\u3002",
+  "\u30FB",
+  "\uFF09",
+  "\u3015",
+  "\u3009",
+  "\u300B",
+  "\u300D",
+  "\u300F",
+  "\u3011"
+]);
+var leftStickyPunctuation = /* @__PURE__ */ new Set([
+  ".",
+  ",",
+  "!",
+  "?",
+  ":",
+  ";",
+  ")",
+  "]",
+  "}",
+  "%",
+  '"',
+  "\u201D",
+  "\u2019",
+  "\xBB",
+  "\u203A",
+  "\u2026"
+]);
+function isCJK(text) {
+  for (const ch of text) {
+    const c = ch.codePointAt(0);
+    if (c !== void 0 && c >= 19968 && c <= 40959 || c !== void 0 && c >= 13312 && c <= 19903 || c !== void 0 && c >= 12288 && c <= 12351 || c !== void 0 && c >= 12352 && c <= 12447 || c !== void 0 && c >= 44032 && c <= 55215 || c !== void 0 && c >= 65280 && c <= 65519) {
+      return true;
+    }
+  }
+  return false;
+}
+function normalizeWhitespace(text) {
+  return text.replace(/[\t\f ]+/g, " ").replace(/^ | $/g, "");
+}
+function segmentText(text, segmentAdapter) {
+  const pieces = [];
+  for (const s of segmentAdapter.segmentWords(text)) {
+    const wordSegment = s.segment;
+    const rawWordLike = s.isWordLike ?? false;
+    const pieceTexts = [];
+    const pieceWordLikes = [];
+    const pieceKinds = [];
+    let currentText = "";
+    let currentKind = null;
+    for (const ch of wordSegment) {
+      let kind;
+      if (ch === " ") {
+        kind = "space";
+      } else if (ch === "\u200B") {
+        kind = "zero-width-break";
+      } else if (ch === "\xAD") {
+        kind = "soft-hyphen";
+      } else if (ch === "\n") {
+        kind = "hard-break";
+      } else {
+        kind = "text";
+      }
+      if (currentKind !== null && kind === currentKind) {
+        currentText += ch;
+      } else {
+        if (currentKind !== null) {
+          pieceTexts.push(currentText);
+          pieceWordLikes.push(currentKind === "text" && rawWordLike);
+          pieceKinds.push(currentKind);
+        }
+        currentText = ch;
+        currentKind = kind;
+      }
+    }
+    if (currentKind !== null) {
+      pieceTexts.push(currentText);
+      pieceWordLikes.push(currentKind === "text" && rawWordLike);
+      pieceKinds.push(currentKind);
+    }
+    pieces.push({ texts: pieceTexts, isWordLike: pieceWordLikes, kinds: pieceKinds });
+  }
+  return pieces;
+}
+function* fallbackSegmentWords(text) {
+  let index = 0;
+  let current = "";
+  let currentIndex = 0;
+  let currentWordLike = null;
+  const flush = () => {
+    if (current.length === 0 || currentWordLike === null) return void 0;
+    const out2 = { segment: current, index: currentIndex, isWordLike: currentWordLike };
+    current = "";
+    currentWordLike = null;
+    return out2;
+  };
+  for (const ch of text) {
+    const isWordLike = !/[\s\u200B\u00AD]/u.test(ch);
+    if (currentWordLike !== null && currentWordLike !== isWordLike) {
+      const out2 = flush();
+      if (out2) yield out2;
+    }
+    if (currentWordLike === null) {
+      currentWordLike = isWordLike;
+      currentIndex = index;
+    }
+    current += ch;
+    index += ch.length;
+  }
+  const out = flush();
+  if (out) yield out;
+}
+function* fallbackSegmentGraphemes(text) {
+  let index = 0;
+  for (const ch of text) {
+    yield { segment: ch, index };
+    index += ch.length;
+  }
+}
+function createDefaultSegmentAdapter() {
+  return {
+    segmentWords(text) {
+      return fallbackSegmentWords(text);
+    },
+    segmentGraphemes(text) {
+      return fallbackSegmentGraphemes(text);
+    }
+  };
+}
+var defaultSegmentAdapter = null;
+function getDefaultSegmentAdapter() {
+  if (defaultSegmentAdapter === null) {
+    defaultSegmentAdapter = createDefaultSegmentAdapter();
+  }
+  return defaultSegmentAdapter;
+}
+function measuredWidth(value) {
+  const width = typeof value === "number" ? value : value.width;
+  return Number.isFinite(width) && width >= 0 ? width : 0;
+}
+function metricKey(text, font) {
+  return `${font}\0${text}`;
+}
+var InjectedMeasureAdapter = class {
+  measure;
+  shouldCache;
+  cache = /* @__PURE__ */ new Map();
+  constructor(measure, opts = {}) {
+    this.measure = measure;
+    this.shouldCache = opts.cache ?? true;
+  }
+  measureSegment(text, font) {
+    const key = metricKey(text, font);
+    if (this.shouldCache) {
+      const cached = this.cache.get(key);
+      if (cached !== void 0) return { width: cached };
+    }
+    const width = measuredWidth(this.measure(text, font));
+    if (this.shouldCache) this.cache.set(key, width);
+    return { width };
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+};
+var PrecomputedMeasureAdapter = class {
+  metrics;
+  fallback;
+  cellWidth;
+  constructor(opts) {
+    this.metrics = opts.metrics instanceof Map ? opts.metrics : new Map(Object.entries(opts.metrics));
+    this.fallback = opts.fallback ?? "error";
+    this.cellWidth = nonNegativeFinite(opts.cellWidth ?? 8, 8);
+  }
+  measureSegment(text, font) {
+    const fontScoped = this.metrics.get(metricKey(text, font));
+    if (fontScoped !== void 0) return { width: nonNegativeFinite(fontScoped, 0) };
+    const unscoped = this.metrics.get(text);
+    if (unscoped !== void 0) return { width: nonNegativeFinite(unscoped, 0) };
+    if (this.fallback === "per-char") {
+      return { width: Array.from(text).length * this.cellWidth };
+    }
+    throw new Error(`No precomputed metric for segment ${JSON.stringify(text)}`);
+  }
+};
+var CellMeasureAdapter = class {
+  cellWidth;
+  wideCellWidth;
+  tabCells;
+  constructor(opts = {}) {
+    this.cellWidth = nonNegativeFinite(opts.cellWidth ?? 8, 8);
+    this.wideCellWidth = nonNegativeFinite(
+      opts.wideCellWidth ?? this.cellWidth * 2,
+      this.cellWidth * 2
+    );
+    this.tabCells = Math.max(1, Math.floor(nonNegativeFinite(opts.tabCells ?? 4, 4)));
+  }
+  measureSegment(text) {
+    let width = 0;
+    for (const char of text) {
+      if (char === "	") width += this.cellWidth * this.tabCells;
+      else width += isCJK(char) ? this.wideCellWidth : this.cellWidth;
+    }
+    return { width };
+  }
+};
+var CapabilityMeasureAdapter = class {
+  capability;
+  constructor(capability) {
+    this.capability = capability;
+  }
+  measureSegment(text, font) {
+    return { width: measuredWidth(this.capability.measureText(text, font)) };
+  }
+  clearCache() {
+    this.capability.clearCache?.();
+  }
+};
+function stripSvgIgnoredContent(svg) {
+  return svg.replace(/<!--[\s\S]*?-->/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "");
+}
+function readSvgRootTag(svg) {
+  return /<svg\b[^>]*>/i.exec(svg)?.[0] ?? null;
+}
+function readNumericAttr(tag, attr) {
+  const pattern = new RegExp(`(?:^|\\s)${attr}\\s*=\\s*["']?(-?\\d+(?:\\.\\d+)?)`, "i");
+  const match = pattern.exec(tag);
+  if (!match) return null;
+  const value = Number(match[1]);
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function readViewBox(tag) {
+  const match = /\bviewBox\s*=\s*["']\s*(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s*["']/i.exec(
+    tag
+  );
+  if (!match) return null;
+  const width = Number(match[3]);
+  const height = Number(match[4]);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width < 0 || height < 0) {
+    return null;
+  }
+  return { width, height };
+}
+var SvgBoundsAdapter = class {
+  measureSvg(svg) {
+    const cleaned = stripSvgIgnoredContent(svg);
+    const rootTag = readSvgRootTag(cleaned);
+    if (rootTag === null) throw new Error("Cannot measure SVG without a root <svg> element");
+    const width = readNumericAttr(rootTag, "width");
+    const height = readNumericAttr(rootTag, "height");
+    if (width !== null && height !== null) return { width, height };
+    const viewBox = readViewBox(rootTag);
+    if (viewBox) return viewBox;
+    throw new Error("Cannot measure SVG without width/height or viewBox");
+  }
+};
+var ImageSizeAdapter = class {
+  sizes;
+  constructor(sizes) {
+    this.sizes = isImageSizeLookup(sizes) ? sizes : new Map(Object.entries(sizes));
+  }
+  measureImage(src) {
+    const size = this.sizes.get(src);
+    if (!size) throw new Error(`No image size registered for ${JSON.stringify(src)}`);
+    return size;
+  }
+};
+function isImageSizeLookup(value) {
+  if (value === null) return false;
+  const valueType = typeof value;
+  if (valueType !== "object" && valueType !== "function") return false;
+  return typeof value.get === "function";
+}
+function measurementIssue(code, message, targetId, measurementKind, opts = {}) {
+  return {
+    kind: "issue",
+    code,
+    message,
+    severity: opts.severity ?? "warning",
+    source: opts.source,
+    subjectId: targetId,
+    measurementKind,
+    details: opts.details,
+    metadata: opts.metadata
+  };
+}
+function measurementOk(targetId, measurementKind, value, opts = {}) {
+  return {
+    kind: "ok",
+    targetId,
+    measurementKind,
+    value,
+    source: opts.source,
+    metadata: opts.metadata
+  };
+}
+function latestMeasurementValue(measurements, targetId, measurementKind) {
+  let value;
+  for (const fact of measurements) {
+    if (fact.kind === "ok" && fact.targetId === targetId && fact.measurementKind === measurementKind) {
+      value = fact.value;
+    }
+  }
+  return value;
+}
+function tryMeasureHyphenWidth(adapter, font) {
+  try {
+    return nonNegativeFinite(adapter.measureSegment("-", font).width, 0);
+  } catch {
+    return void 0;
+  }
+}
+function validMeasurementSize(size, label) {
+  if (!Number.isFinite(size.width) || !Number.isFinite(size.height) || size.width < 0 || size.height < 0) {
+    throw new Error(`Invalid ${label} measurement size`);
+  }
+  return size;
+}
+function textMeasurementFacts(text, font, adapter, cache, segmentAdapter, targetId, source) {
+  try {
+    const segments = analyzeAndMeasure(text, font, adapter, cache, void 0, segmentAdapter);
+    const hyphenWidth = tryMeasureHyphenWidth(adapter, font);
+    const facts = [
+      measurementOk(
+        targetId,
+        TEXT_SEGMENTS_MEASUREMENT_KIND,
+        hyphenWidth === void 0 ? { segments } : { segments, hyphenWidth },
+        { source }
+      )
+    ];
+    if (hyphenWidth === void 0) {
+      facts.push(
+        measurementIssue(
+          "measurement.hyphen.failed",
+          `Hyphen measurement failed for '${targetId}'`,
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND,
+          { source, severity: "warning" }
+        )
+      );
+    }
+    return facts;
+  } catch (error) {
+    return [
+      measurementIssue(
+        "measurement.failed",
+        `Text measurement failed for '${targetId}'`,
+        targetId,
+        TEXT_SEGMENTS_MEASUREMENT_KIND,
+        { source, details: error, severity: "error" }
+      )
+    ];
+  }
+}
+function inputNode(g, input, fallback, name) {
+  if (input instanceof Node) {
+    return {
+      node: input,
+      set(value) {
+        const maybeState = input;
+        if (typeof maybeState.set !== "function") {
+          throw new TypeError(`reactive-layout input '${name}' is not a writable state node`);
+        }
+        maybeState.set(value);
+      }
+    };
+  }
+  const state = g.state(input ?? fallback, { name });
+  return { node: state, set: (value) => state.set(value) };
+}
+function scopedName(scope, local) {
+  return scope === local ? local : `${scope}:${local}`;
+}
+function textMeasurementProvider(opts) {
+  const targetId = opts.targetId ?? "text";
+  const name = opts.name ?? `${targetId}-measurements`;
+  const source = opts.source ?? name;
+  const cache = /* @__PURE__ */ new Map();
+  let activeAdapter = null;
+  return opts.graph.node(
+    opts.segmentAdapter ? [opts.text, opts.font, opts.adapter, opts.segmentAdapter] : [opts.text, opts.font, opts.adapter],
+    (ctx) => {
+      const flush = () => {
+        cache.clear();
+        depLatest(ctx, 2).clearCache?.();
+      };
+      ctx.onDeactivation(flush);
+      ctx.onInvalidate(flush);
+      const text = depLatest(ctx, 0);
+      const font = depLatest(ctx, 1);
+      const adapter = depLatest(ctx, 2);
+      if (adapter !== activeAdapter) {
+        cache.clear();
+        activeAdapter = adapter;
+      }
+      const segmentAdapter = opts.segmentAdapter === void 0 ? getDefaultSegmentAdapter() : depLatest(ctx, 3);
+      ctx.down([
+        [
+          "DATA",
+          textMeasurementFacts(text, font, adapter, cache, segmentAdapter, targetId, source)
+        ]
+      ]);
+    },
+    { name }
+  );
+}
+function injectedTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const adapter = opts.graph.state(
+    new InjectedMeasureAdapter(opts.measure, { cache: opts.cache }),
+    {
+      name: opts.name ? scopedName(opts.name, "measure-capability") : `${targetId}-measure-capability`
+    }
+  );
+  return textMeasurementProvider({
+    ...opts,
+    adapter,
+    source: opts.source ?? "injectedTextMeasurements"
+  });
+}
+function precomputedTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const adapter = opts.graph.state(new PrecomputedMeasureAdapter(opts), {
+    name: opts.name ? scopedName(opts.name, "measure-capability") : `${targetId}-measure-capability`
+  });
+  return textMeasurementProvider({
+    ...opts,
+    adapter,
+    source: opts.source ?? "precomputedTextMeasurements"
+  });
+}
+function cellTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const adapter = opts.graph.state(new CellMeasureAdapter(opts), {
+    name: opts.name ? scopedName(opts.name, "measure-capability") : `${targetId}-measure-capability`
+  });
+  return textMeasurementProvider({
+    ...opts,
+    adapter,
+    source: opts.source ?? "cellTextMeasurements"
+  });
+}
+function capabilityTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const adapter = opts.graph.node(
+    [opts.capability],
+    (ctx) => {
+      ctx.down([
+        ["DATA", new CapabilityMeasureAdapter(depLatest(ctx, 0))]
+      ]);
+    },
+    {
+      name: opts.name ? scopedName(opts.name, "measure-capability") : `${targetId}-measure-capability`
+    }
+  );
+  return textMeasurementProvider({
+    ...opts,
+    adapter,
+    source: opts.source ?? "capabilityTextMeasurements"
+  });
+}
+function readinessTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const name = opts.name ?? `${targetId}-measurements`;
+  const source = opts.source ?? name;
+  const cache = /* @__PURE__ */ new Map();
+  let activeAdapter = null;
+  let activeReadiness = null;
+  const deps = opts.segmentAdapter ? [opts.text, opts.font, opts.adapter, opts.readiness, opts.segmentAdapter] : [opts.text, opts.font, opts.adapter, opts.readiness];
+  return opts.graph.node(
+    deps,
+    (ctx) => {
+      const flush = () => {
+        cache.clear();
+        depLatest(ctx, 2).clearCache?.();
+      };
+      ctx.onDeactivation(flush);
+      ctx.onInvalidate(flush);
+      const text = depLatest(ctx, 0);
+      const font = depLatest(ctx, 1);
+      const adapter = depLatest(ctx, 2);
+      if (adapter !== activeAdapter) {
+        cache.clear();
+        activeAdapter = adapter;
+      }
+      const readiness = depLatest(ctx, 3);
+      if (readiness !== activeReadiness) {
+        cache.clear();
+        activeReadiness = readiness;
+      }
+      if (!readiness.ready) {
+        ctx.down([
+          [
+            "DATA",
+            [
+              measurementIssue(
+                readiness.code ?? "measurement.not-ready",
+                readiness.message ?? `Measurement readiness blocked '${targetId}'`,
+                targetId,
+                TEXT_SEGMENTS_MEASUREMENT_KIND,
+                {
+                  source: readiness.source ?? source,
+                  details: readiness.details,
+                  metadata: readiness.metadata,
+                  severity: "warning"
+                }
+              )
+            ]
+          ]
+        ]);
+        return;
+      }
+      const segmentAdapter = opts.segmentAdapter === void 0 ? getDefaultSegmentAdapter() : depLatest(ctx, 4);
+      ctx.down([
+        [
+          "DATA",
+          textMeasurementFacts(text, font, adapter, cache, segmentAdapter, targetId, source)
+        ]
+      ]);
+    },
+    { name }
+  );
+}
+function readinessMeasurements(opts) {
+  const targetId = opts.targetId ?? "measurement-readiness";
+  const measurementKind = opts.measurementKind ?? READINESS_MEASUREMENT_KIND;
+  const name = opts.name ?? `${targetId}-measurements`;
+  const source = opts.source ?? name;
+  return opts.graph.node(
+    [opts.readiness],
+    (ctx) => {
+      const readiness = depLatest(ctx, 0);
+      if (!readiness.ready) {
+        ctx.down([
+          [
+            "DATA",
+            [
+              measurementIssue(
+                readiness.code ?? "measurement.not-ready",
+                readiness.message ?? `Measurement readiness blocked '${targetId}'`,
+                targetId,
+                measurementKind,
+                {
+                  source: readiness.source ?? source,
+                  details: readiness.details,
+                  metadata: readiness.metadata,
+                  severity: "warning"
+                }
+              )
+            ]
+          ]
+        ]);
+        return;
+      }
+      ctx.down([
+        [
+          "DATA",
+          [
+            measurementOk(targetId, measurementKind, readiness, {
+              source: readiness.source ?? source,
+              metadata: readiness.metadata
+            })
+          ]
+        ]
+      ]);
+    },
+    { name }
+  );
+}
+function imageSizeMeasurements(opts) {
+  const measurementKind = opts.measurementKind ?? IMAGE_SIZE_MEASUREMENT_KIND;
+  const name = opts.name ?? "image-size-measurements";
+  const source = opts.source ?? name;
+  return opts.graph.node(
+    [opts.images, opts.measurer],
+    (ctx) => {
+      const images = depLatest(ctx, 0);
+      const measurer = depLatest(ctx, 1);
+      const facts = [];
+      for (let i = 0; i < images.length; i += 1) {
+        const image = images[i];
+        const subjectId = image?.id ?? image?.src ?? `image:${i}`;
+        try {
+          if (image === void 0) throw new Error(`Missing image target at index ${i}`);
+          facts.push(
+            measurementOk(
+              subjectId,
+              measurementKind,
+              validMeasurementSize(measurer.measureImage(image.src), "image"),
+              {
+                source,
+                metadata: image.metadata
+              }
+            )
+          );
+        } catch (error) {
+          facts.push(
+            measurementIssue(
+              "measurement.image-size.failed",
+              `Image size measurement failed for '${subjectId}'`,
+              subjectId,
+              measurementKind,
+              {
+                source,
+                details: { error, index: i, src: image?.src },
+                metadata: image?.metadata,
+                severity: "error"
+              }
+            )
+          );
+        }
+      }
+      ctx.down([["DATA", facts]]);
+    },
+    { name }
+  );
+}
+function svgBoundsMeasurements(opts) {
+  const measurementKind = opts.measurementKind ?? SVG_BOUNDS_MEASUREMENT_KIND;
+  const name = opts.name ?? "svg-bounds-measurements";
+  const source = opts.source ?? name;
+  return opts.graph.node(
+    [opts.svgs, opts.measurer],
+    (ctx) => {
+      const svgs = depLatest(ctx, 0);
+      const measurer = depLatest(ctx, 1);
+      const facts = [];
+      for (let i = 0; i < svgs.length; i += 1) {
+        const svg = svgs[i];
+        const subjectId = svg?.id ?? `svg:${i}`;
+        try {
+          if (svg === void 0) throw new Error(`Missing SVG target at index ${i}`);
+          facts.push(
+            measurementOk(
+              subjectId,
+              measurementKind,
+              validMeasurementSize(measurer.measureSvg(svg.svg), "SVG"),
+              {
+                source,
+                metadata: svg.metadata
+              }
+            )
+          );
+        } catch (error) {
+          facts.push(
+            measurementIssue(
+              "measurement.svg-bounds.failed",
+              `SVG bounds measurement failed for '${subjectId}'`,
+              subjectId,
+              measurementKind,
+              {
+                source,
+                details: { error, index: i },
+                metadata: svg?.metadata,
+                severity: "error"
+              }
+            )
+          );
+        }
+      }
+      ctx.down([["DATA", facts]]);
+    },
+    { name }
+  );
+}
+function mergeMeasurements(opts) {
+  const sources = [...opts.sources];
+  return opts.graph.node(
+    sources,
+    (ctx) => {
+      const facts = [];
+      for (let i = 0; i < sources.length; i += 1) {
+        facts.push(...depLatest(ctx, i));
+      }
+      ctx.down([["DATA", facts]]);
+    },
+    { name: opts.name ?? "measurements" }
+  );
+}
+function blockAdaptersProvider(opts) {
+  const deps = [];
+  const positions = {};
+  if (opts.text) {
+    positions.text = deps.length;
+    deps.push(opts.text);
+  }
+  if (opts.svg) {
+    positions.svg = deps.length;
+    deps.push(opts.svg);
+  }
+  if (opts.image) {
+    positions.image = deps.length;
+    deps.push(opts.image);
+  }
+  return opts.graph.node(
+    deps,
+    (ctx) => {
+      const adapters = {
+        text: positions.text === void 0 ? void 0 : depLatest(ctx, positions.text),
+        svg: positions.svg === void 0 ? void 0 : depLatest(ctx, positions.svg),
+        image: positions.image === void 0 ? void 0 : depLatest(ctx, positions.image)
+      };
+      ctx.down([["DATA", adapters]]);
+    },
+    { name: opts.name ?? "block-adapters" }
+  );
+}
+function blockMeasurementProvider(opts) {
+  const targetId = opts.targetId ?? "blocks";
+  const name = opts.name ?? `${targetId}-measurements`;
+  const source = opts.source ?? name;
+  const cache = /* @__PURE__ */ new Map();
+  let activeTextAdapter;
+  const deps = [opts.blocks, opts.maxWidth, opts.adapters];
+  if (opts.font) deps.push(opts.font);
+  if (opts.lineHeight) deps.push(opts.lineHeight);
+  if (opts.segmentAdapter) deps.push(opts.segmentAdapter);
+  return opts.graph.node(
+    deps,
+    (ctx) => {
+      const flush = () => {
+        cache.clear();
+        const adapters = depLatest(ctx, 2);
+        adapters.text?.clearCache?.();
+      };
+      ctx.onDeactivation(flush);
+      ctx.onInvalidate(flush);
+      try {
+        const blocks = depLatest(ctx, 0);
+        const maxWidth = nonNegativeFinite(depLatest(ctx, 1), 0);
+        const adapters = depLatest(ctx, 2);
+        if (adapters.text !== activeTextAdapter) {
+          cache.clear();
+          activeTextAdapter = adapters.text;
+        }
+        let depIndex = 3;
+        const font = opts.font ? depLatest(ctx, depIndex++) : void 0;
+        const lineHeight = opts.lineHeight ? nonNegativeFinite(depLatest(ctx, depIndex++), 0) : void 0;
+        const segmentAdapter = opts.segmentAdapter ? depLatest(ctx, depIndex) : getDefaultSegmentAdapter();
+        const measured = [];
+        const issues = [];
+        for (let i = 0; i < blocks.length; i += 1) {
+          const block = blocks[i];
+          const subjectId = block?.id ?? `${targetId}:${i}`;
+          try {
+            if (block === void 0) {
+              throw new Error(`Missing content block at index ${i}`);
+            }
+            const blockFont = block.kind === "text" ? block.font ?? font ?? "16px sans-serif" : void 0;
+            const hyphenWidth = block.kind === "text" && adapters.text ? tryMeasureHyphenWidth(adapters.text, blockFont ?? "16px sans-serif") : void 0;
+            measured.push(
+              measureBlock(block, {
+                adapters,
+                font,
+                hyphenWidth,
+                lineHeight,
+                maxWidth,
+                cache,
+                segmentAdapter
+              })
+            );
+            if (block.kind === "text" && adapters.text) {
+              if (hyphenWidth === void 0) {
+                issues.push(
+                  measurementIssue(
+                    "measurement.hyphen.failed",
+                    `Hyphen measurement failed for '${subjectId}'`,
+                    subjectId,
+                    BLOCKS_MEASUREMENT_KIND,
+                    {
+                      source,
+                      details: { targetId, index: i },
+                      severity: "warning"
+                    }
+                  )
+                );
+              }
+            }
+          } catch (error) {
+            issues.push(
+              measurementIssue(
+                "measurement.block.failed",
+                `Block measurement failed for '${subjectId}'`,
+                subjectId,
+                BLOCKS_MEASUREMENT_KIND,
+                {
+                  source,
+                  details: { error, targetId, index: i, blockKind: block?.kind },
+                  severity: "error"
+                }
+              )
+            );
+          }
+        }
+        ctx.down([
+          [
+            "DATA",
+            [
+              measurementOk(
+                targetId,
+                BLOCKS_MEASUREMENT_KIND,
+                { blocks: measured },
+                { source }
+              ),
+              ...issues
+            ]
+          ]
+        ]);
+      } catch (error) {
+        ctx.down([
+          [
+            "DATA",
+            [
+              measurementIssue(
+                "measurement.failed",
+                `Block measurement failed for '${targetId}'`,
+                targetId,
+                BLOCKS_MEASUREMENT_KIND,
+                { source, details: error, severity: "error" }
+              )
+            ]
+          ]
+        ]);
+      }
+    },
+    { name }
+  );
+}
+function analyzeAndMeasure(text, font, adapter, cache, stats, segmentAdapter) {
+  const normalized = normalizeWhitespace(text);
+  if (normalized.length === 0) {
+    return [];
+  }
+  const segAdapter = segmentAdapter ?? getDefaultSegmentAdapter();
+  const pieces = segmentText(normalized, segAdapter);
+  const rawTexts = [];
+  const rawKinds = [];
+  const rawWordLike = [];
+  for (const piece of pieces) {
+    for (let i = 0; i < piece.texts.length; i += 1) {
+      rawTexts.push(piece.texts[i]);
+      rawKinds.push(piece.kinds[i]);
+      rawWordLike.push(piece.isWordLike[i]);
+    }
+  }
+  const mergedTexts = [];
+  const mergedKinds = [];
+  const mergedWordLike = [];
+  for (let i = 0; i < rawTexts.length; i += 1) {
+    const t = rawTexts[i];
+    const k = rawKinds[i];
+    const wl = rawWordLike[i];
+    if (k === "text" && !wl && mergedTexts.length > 0 && mergedKinds[mergedTexts.length - 1] === "text") {
+      const isSticky = t.length === 1 && (leftStickyPunctuation.has(t) || kinsokuStart.has(t));
+      if (isSticky) {
+        mergedTexts[mergedTexts.length - 1] += t;
+        continue;
+      }
+    }
+    if (t === "-" && mergedTexts.length > 0 && mergedKinds[mergedKinds.length - 1] === "text" && mergedWordLike[mergedWordLike.length - 1]) {
+      mergedTexts[mergedTexts.length - 1] += t;
+      continue;
+    }
+    mergedTexts.push(t);
+    mergedKinds.push(k);
+    mergedWordLike.push(wl);
+  }
+  const fontCache = cache.get(font) ?? /* @__PURE__ */ new Map();
+  if (!cache.has(font)) cache.set(font, fontCache);
+  function measureCached(segment) {
+    const cached = fontCache.get(segment);
+    if (cached === void 0) {
+      if (stats) stats.misses += 1;
+      const measured = adapter.measureSegment(segment, font).width;
+      const width = Number.isFinite(measured) && measured >= 0 ? measured : 0;
+      fontCache.set(segment, width);
+      return width;
+    }
+    if (stats) stats.hits += 1;
+    return cached;
+  }
+  const out = [];
+  for (let i = 0; i < mergedTexts.length; i += 1) {
+    const t = mergedTexts[i];
+    const kind = mergedKinds[i];
+    if (kind !== "text") {
+      out.push({
+        text: t,
+        width: kind === "space" ? measureCached(" ") * t.length : 0,
+        kind,
+        graphemeWidths: null
+      });
+      continue;
+    }
+    if (isCJK(t)) {
+      let unitText = "";
+      for (const graphemeSegment of segAdapter.segmentGraphemes(t)) {
+        const grapheme = graphemeSegment.segment;
+        if (unitText.length > 0 && kinsokuStart.has(grapheme)) {
+          unitText += grapheme;
+          continue;
+        }
+        if (unitText.length > 0) {
+          out.push({
+            text: unitText,
+            width: measureCached(unitText),
+            kind: "text",
+            graphemeWidths: null
+          });
+        }
+        unitText = grapheme;
+      }
+      if (unitText.length > 0) {
+        out.push({
+          text: unitText,
+          width: measureCached(unitText),
+          kind: "text",
+          graphemeWidths: null
+        });
+      }
+      continue;
+    }
+    const textWidth = measureCached(t);
+    let graphemeWidths = null;
+    if (mergedWordLike[i] && t.length > 1) {
+      const widths = [];
+      for (const grapheme of segAdapter.segmentGraphemes(t)) {
+        widths.push(measureCached(grapheme.segment));
+      }
+      if (widths.length > 1) graphemeWidths = widths;
+    }
+    out.push({
+      text: t,
+      width: textWidth,
+      kind: "text",
+      graphemeWidths
+    });
+  }
+  return out;
+}
+function computeLineBreaks(segments, maxWidth, opts = {}) {
+  if (segments.length === 0) return { lines: [], lineCount: 0 };
+  const segAdapter = opts.segmentAdapter ?? getDefaultSegmentAdapter();
+  const lines = [];
+  let cursor = { segmentIndex: 0, graphemeIndex: 0 };
+  while (cursor.segmentIndex < segments.length) {
+    const next = layoutNextLine(segments, cursor, maxWidth, {
+      hyphenWidth: opts.hyphenWidth,
+      segmentAdapter: segAdapter
+    });
+    if (next === null) break;
+    lines.push({
+      text: next.text,
+      width: next.width,
+      startSegment: next.start.segmentIndex,
+      startGrapheme: next.start.graphemeIndex,
+      endSegment: next.end.segmentIndex,
+      endGrapheme: next.end.graphemeIndex
+    });
+    if (next.end.segmentIndex === cursor.segmentIndex && next.end.graphemeIndex === cursor.graphemeIndex) {
+      break;
+    }
+    cursor = next.end;
+  }
+  return { lines, lineCount: lines.length };
+}
+function canBreakAfter(kind) {
+  return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
+}
+function sliceSegmentText(seg, startGrapheme, endGrapheme, segmentAdapter) {
+  if (startGrapheme === 0 && endGrapheme < 0) return seg.text;
+  const graphemes = [...segmentAdapter.segmentGraphemes(seg.text)].map((g) => g.segment);
+  const stop = endGrapheme < 0 ? graphemes.length : endGrapheme;
+  return graphemes.slice(startGrapheme, stop).join("");
+}
+function buildLineText(segments, startSegment, startGrapheme, endSegment, endGrapheme, appendHyphen, segmentAdapter) {
+  let text = "";
+  for (let i = startSegment; i < endSegment; i += 1) {
+    const seg = segments[i];
+    if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") continue;
+    if (i === startSegment && startGrapheme > 0) {
+      text += sliceSegmentText(seg, startGrapheme, -1, segmentAdapter);
+    } else {
+      text += seg.text;
+    }
+  }
+  if (endGrapheme > 0 && endSegment < segments.length) {
+    const seg = segments[endSegment];
+    const from = startSegment === endSegment ? startGrapheme : 0;
+    text += sliceSegmentText(seg, from, endGrapheme, segmentAdapter);
+  }
+  if (appendHyphen) text += "-";
+  return text;
+}
+function resolveHyphenWidth(ctx) {
+  if (ctx?.hyphenWidth !== void 0) return nonNegativeFinite(ctx.hyphenWidth, 0);
+  if (ctx?.adapter === void 0 || ctx.font === void 0) return 0;
+  const cache = ctx.cache;
+  if (cache) {
+    let fontCache = cache.get(ctx.font);
+    if (fontCache === void 0) {
+      fontCache = /* @__PURE__ */ new Map();
+      cache.set(ctx.font, fontCache);
+    }
+    let width = fontCache.get("-");
+    if (width === void 0) {
+      width = ctx.adapter.measureSegment("-", ctx.font).width;
+      fontCache.set("-", width);
+    }
+    return width;
+  }
+  return ctx.adapter.measureSegment("-", ctx.font).width;
+}
+function layoutNextLine(segments, cursor, slotWidth, ctx) {
+  let i = cursor.segmentIndex;
+  const initialGrapheme = cursor.graphemeIndex;
+  const segmentAdapter = ctx?.segmentAdapter ?? getDefaultSegmentAdapter();
+  if (i >= segments.length) return null;
+  if (initialGrapheme === 0) {
+    while (i < segments.length) {
+      const seg = segments[i];
+      if (seg.kind === "hard-break") {
+        return {
+          text: "",
+          width: 0,
+          start: { segmentIndex: cursor.segmentIndex, graphemeIndex: 0 },
+          end: { segmentIndex: i + 1, graphemeIndex: 0 }
+        };
+      }
+      if (seg.kind === "space" || seg.kind === "zero-width-break" || seg.kind === "soft-hyphen") {
+        i += 1;
+        continue;
+      }
+      break;
+    }
+    if (i >= segments.length) return null;
+  }
+  const hyphenWidth = resolveHyphenWidth(ctx);
+  const startSegment = i;
+  const startGrapheme = i === cursor.segmentIndex ? initialGrapheme : 0;
+  let lineW = 0;
+  let lineEndSegment = startSegment;
+  let lineEndGrapheme = 0;
+  let hasContent = false;
+  let pendingBreakSegment = -1;
+  let pendingBreakGrapheme = 0;
+  let pendingBreakWidth = 0;
+  let pendingBreakSoftHyphen = false;
+  const recordPending = (sIdx, gIdx, width, kind) => {
+    pendingBreakSegment = sIdx;
+    pendingBreakGrapheme = gIdx;
+    pendingBreakWidth = width;
+    pendingBreakSoftHyphen = kind === "soft-hyphen";
+  };
+  const consumeBreakable = (segIdx, startG, widths) => {
+    for (let g = startG; g < widths.length; g += 1) {
+      const gw = widths[g];
+      if (!hasContent) {
+        lineW = gw;
+        lineEndSegment = segIdx;
+        lineEndGrapheme = g + 1;
+        hasContent = true;
+        continue;
+      }
+      if (lineW + gw > slotWidth + 1e-3) {
+        return true;
+      }
+      lineW += gw;
+      lineEndSegment = segIdx;
+      lineEndGrapheme = g + 1;
+    }
+    if (lineEndSegment === segIdx && lineEndGrapheme === widths.length) {
+      lineEndSegment = segIdx + 1;
+      lineEndGrapheme = 0;
+    }
+    return false;
+  };
+  if (startGrapheme > 0 && startSegment < segments.length) {
+    const seg = segments[startSegment];
+    if (seg.graphemeWidths) {
+      const overflow = consumeBreakable(startSegment, startGrapheme, seg.graphemeWidths);
+      if (overflow) {
+        const text2 = buildLineText(
+          segments,
+          startSegment,
+          startGrapheme,
+          lineEndSegment,
+          lineEndGrapheme,
+          false,
+          segmentAdapter
+        );
+        return {
+          text: text2,
+          width: lineW,
+          start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+          end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+        };
+      }
+      i = lineEndSegment;
+    }
+  }
+  for (; i < segments.length; i += 1) {
+    const seg = segments[i];
+    if (seg.kind === "hard-break") {
+      if (hasContent) {
+        const endsAtSoftHyphen2 = lineEndSegment > 0 && segments[lineEndSegment - 1]?.kind === "soft-hyphen";
+        const text2 = buildLineText(
+          segments,
+          startSegment,
+          startGrapheme,
+          lineEndSegment,
+          lineEndGrapheme,
+          endsAtSoftHyphen2,
+          segmentAdapter
+        );
+        return {
+          text: text2,
+          width: lineW + (endsAtSoftHyphen2 ? hyphenWidth : 0),
+          start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+          end: { segmentIndex: i + 1, graphemeIndex: 0 }
+        };
+      }
+      return {
+        text: "",
+        width: 0,
+        start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+        end: { segmentIndex: i + 1, graphemeIndex: 0 }
+      };
+    }
+    const w = seg.width;
+    if (!hasContent) {
+      if (w > slotWidth && seg.graphemeWidths) {
+        const overflow = consumeBreakable(i, 0, seg.graphemeWidths);
+        if (overflow) {
+          const text2 = buildLineText(
+            segments,
+            startSegment,
+            startGrapheme,
+            lineEndSegment,
+            lineEndGrapheme,
+            false,
+            segmentAdapter
+          );
+          return {
+            text: text2,
+            width: lineW,
+            start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+            end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+          };
+        }
+        i = lineEndSegment - 1;
+        continue;
+      }
+      lineW = w;
+      lineEndSegment = i + 1;
+      lineEndGrapheme = 0;
+      hasContent = true;
+      if (canBreakAfter(seg.kind)) {
+        recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
+      }
+      continue;
+    }
+    const projectedWidth = lineW + w;
+    if (projectedWidth > slotWidth + 1e-3) {
+      if (canBreakAfter(seg.kind)) {
+        lineEndSegment = i + 1;
+        lineEndGrapheme = 0;
+        const endsAtSoftHyphen2 = seg.kind === "soft-hyphen";
+        const text3 = buildLineText(
+          segments,
+          startSegment,
+          startGrapheme,
+          lineEndSegment,
+          lineEndGrapheme,
+          endsAtSoftHyphen2,
+          segmentAdapter
+        );
+        return {
+          text: text3,
+          width: seg.kind === "space" ? lineW : lineW + (endsAtSoftHyphen2 ? hyphenWidth : 0),
+          start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+          end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+        };
+      }
+      if (pendingBreakSegment >= 0) {
+        const text3 = buildLineText(
+          segments,
+          startSegment,
+          startGrapheme,
+          pendingBreakSegment,
+          pendingBreakGrapheme,
+          pendingBreakSoftHyphen,
+          segmentAdapter
+        );
+        return {
+          text: text3,
+          width: pendingBreakWidth + (pendingBreakSoftHyphen ? hyphenWidth : 0),
+          start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+          end: { segmentIndex: pendingBreakSegment, graphemeIndex: pendingBreakGrapheme }
+        };
+      }
+      if (w > slotWidth && seg.graphemeWidths) {
+        const text3 = buildLineText(
+          segments,
+          startSegment,
+          startGrapheme,
+          lineEndSegment,
+          lineEndGrapheme,
+          false,
+          segmentAdapter
+        );
+        return {
+          text: text3,
+          width: lineW,
+          start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+          end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+        };
+      }
+      const text2 = buildLineText(
+        segments,
+        startSegment,
+        startGrapheme,
+        lineEndSegment,
+        lineEndGrapheme,
+        false,
+        segmentAdapter
+      );
+      return {
+        text: text2,
+        width: lineW,
+        start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+        end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+      };
+    }
+    lineW = projectedWidth;
+    lineEndSegment = i + 1;
+    lineEndGrapheme = 0;
+    if (canBreakAfter(seg.kind)) {
+      recordPending(i + 1, 0, seg.kind === "space" ? lineW - w : lineW, seg.kind);
+    }
+  }
+  if (!hasContent) return null;
+  const endsAtSoftHyphen = lineEndSegment > 0 && segments[lineEndSegment - 1]?.kind === "soft-hyphen";
+  const text = buildLineText(
+    segments,
+    startSegment,
+    startGrapheme,
+    lineEndSegment,
+    lineEndGrapheme,
+    endsAtSoftHyphen,
+    segmentAdapter
+  );
+  return {
+    text,
+    width: lineW + (endsAtSoftHyphen ? hyphenWidth : 0),
+    start: { segmentIndex: startSegment, graphemeIndex: startGrapheme },
+    end: { segmentIndex: lineEndSegment, graphemeIndex: lineEndGrapheme }
+  };
+}
+function carveTextLineSlots(base, blocked, minSlotWidth = 0) {
+  let slots = [base];
+  for (const block of blocked) {
+    const next = [];
+    for (const slot of slots) {
+      if (block.right <= slot.left || block.left >= slot.right) {
+        next.push(slot);
+        continue;
+      }
+      if (block.left > slot.left) next.push({ left: slot.left, right: block.left });
+      if (block.right < slot.right) next.push({ left: block.right, right: slot.right });
+    }
+    slots = next;
+  }
+  if (minSlotWidth > 0) return slots.filter((slot) => slot.right - slot.left >= minSlotWidth);
+  return slots;
+}
+function computeCharPositions(lineBreaks, segments, lineHeight, segmentAdapter) {
+  const positions = [];
+  const segAdapter = segmentAdapter ?? getDefaultSegmentAdapter();
+  for (let lineIdx = 0; lineIdx < lineBreaks.lines.length; lineIdx += 1) {
+    const line = lineBreaks.lines[lineIdx];
+    const y = lineIdx * lineHeight;
+    let x = 0;
+    for (let si = line.startSegment; si < segments.length; si += 1) {
+      const seg = segments[si];
+      if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") {
+        if (si >= line.endSegment && line.endGrapheme === 0) break;
+        continue;
+      }
+      const graphemes = [...segAdapter.segmentGraphemes(seg.text)].map((g) => g.segment);
+      if (graphemes.length === 0) continue;
+      const startGrapheme = si === line.startSegment ? line.startGrapheme : 0;
+      let endGrapheme;
+      if (si < line.endSegment) {
+        endGrapheme = graphemes.length;
+      } else if (si === line.endSegment && line.endGrapheme > 0) {
+        endGrapheme = line.endGrapheme;
+      } else {
+        break;
+      }
+      for (let g = startGrapheme; g < endGrapheme; g += 1) {
+        const width = seg.graphemeWidths ? seg.graphemeWidths[g] : seg.width / graphemes.length;
+        positions.push({ x, y, width, height: lineHeight, line: lineIdx });
+        x += width;
+      }
+    }
+  }
+  return positions;
+}
+function nonNegativeFinite(value, fallback) {
+  return Number.isFinite(value) ? Math.max(0, value) : fallback;
+}
+function finiteNumber(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function emitLayoutError(ctx, error, fallback) {
+  ctx.down([["ERROR", errorPayload(error, fallback)]]);
+}
+function positiveFinite(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function clampDimension(value) {
+  return nonNegativeFinite(value ?? 0, 0);
+}
+function fitSize(size, maxWidth) {
+  const width = nonNegativeFinite(size.width, 0);
+  const height = nonNegativeFinite(size.height, 0);
+  if (width === 0 || maxWidth <= 0 || width <= maxWidth) return { width, height };
+  const scale = maxWidth / width;
+  return { width: maxWidth, height: height * scale };
+}
+function blockMaxWidth(blockMaxWidth2, maxWidth) {
+  const own = blockMaxWidth2 === void 0 ? maxWidth : nonNegativeFinite(blockMaxWidth2, maxWidth);
+  if (maxWidth <= 0) return own;
+  if (own <= 0) return maxWidth;
+  return Math.min(own, maxWidth);
+}
+function resolveTextAdapter(opts) {
+  const adapter = opts.adapters?.text ?? opts.adapter;
+  if (!adapter) throw new Error("Text blocks require a MeasurementAdapter");
+  return adapter;
+}
+function measureBlock(block, opts) {
+  const maxWidth = nonNegativeFinite(opts.maxWidth ?? 800, 800);
+  const marginTop = nonNegativeFinite(block.marginTop ?? 0, 0);
+  const marginBottom = nonNegativeFinite(block.marginBottom ?? 0, 0);
+  if (block.kind === "text") {
+    const adapter = resolveTextAdapter(opts);
+    const font = block.font ?? opts.font ?? "16px sans-serif";
+    const lineHeight = positiveFinite(block.lineHeight ?? opts.lineHeight ?? 20, 20);
+    const cache = opts.cache ?? /* @__PURE__ */ new Map();
+    const width = blockMaxWidth(block.maxWidth, maxWidth);
+    const segments = analyzeAndMeasure(
+      block.text,
+      font,
+      adapter,
+      cache,
+      void 0,
+      opts.segmentAdapter
+    );
+    const hyphenWidth = Object.hasOwn(opts, "hyphenWidth") ? opts.hyphenWidth : tryMeasureHyphenWidth(adapter, font);
+    const lineBreaks = computeLineBreaks(segments, width, {
+      hyphenWidth,
+      segmentAdapter: opts.segmentAdapter
+    });
+    const charPositions = computeCharPositions(
+      lineBreaks,
+      segments,
+      lineHeight,
+      opts.segmentAdapter
+    );
+    return {
+      block,
+      kind: block.kind,
+      id: block.id,
+      width: lineBreaks.lines.reduce((acc, line) => Math.max(acc, line.width), 0),
+      height: lineBreaks.lineCount * lineHeight,
+      marginTop,
+      marginBottom,
+      segments,
+      lineBreaks,
+      charPositions
+    };
+  }
+  if (block.kind === "image") {
+    const explicit2 = block.width !== void 0 && block.height !== void 0 ? { width: clampDimension(block.width), height: clampDimension(block.height) } : opts.adapters?.image?.measureImage(block.src);
+    if (!explicit2) throw new Error("Image blocks require width/height or an ImageMeasurer");
+    const size2 = fitSize(explicit2, blockMaxWidth(block.maxWidth, maxWidth));
+    return {
+      block,
+      kind: block.kind,
+      id: block.id,
+      width: size2.width,
+      height: size2.height,
+      marginTop,
+      marginBottom
+    };
+  }
+  const explicit = block.width !== void 0 && block.height !== void 0 ? { width: clampDimension(block.width), height: clampDimension(block.height) } : opts.adapters?.svg?.measureSvg(block.svg);
+  if (!explicit) throw new Error("SVG blocks require width/height or a SvgMeasurer");
+  const size = fitSize(explicit, blockMaxWidth(block.maxWidth, maxWidth));
+  return {
+    block,
+    kind: block.kind,
+    id: block.id,
+    width: size.width,
+    height: size.height,
+    marginTop,
+    marginBottom
+  };
+}
+function measureBlocks(blocks, opts) {
+  const cache = opts.cache ?? /* @__PURE__ */ new Map();
+  return blocks.map((block) => measureBlock(block, { ...opts, cache }));
+}
+function computeBlockFlow(blocks, gap = 0) {
+  const spacing = nonNegativeFinite(gap, 0);
+  let y = 0;
+  return blocks.map((block) => {
+    y += block.marginTop;
+    const positioned = { ...block, x: 0, y };
+    y += block.height + block.marginBottom + spacing;
+    return positioned;
+  });
+}
+function computeTotalHeight(blocks) {
+  if (blocks.length === 0) return 0;
+  let bottom = 0;
+  for (const block of blocks) {
+    bottom = Math.max(bottom, block.y + block.height + block.marginBottom);
+  }
+  return bottom;
+}
+function columnGeometry(container, columns) {
+  const paddingX = nonNegativeFinite(container.paddingX ?? 0, 0);
+  const paddingY = nonNegativeFinite(container.paddingY ?? 0, 0);
+  const count = Math.max(1, Math.floor(nonNegativeFinite(columns?.count ?? 1, 1)));
+  const gap = nonNegativeFinite(columns?.gap ?? 0, 0);
+  const width = nonNegativeFinite(container.width, 0);
+  const height = nonNegativeFinite(container.height, 0);
+  const innerWidth = Math.max(0, width - paddingX * 2 - gap * (count - 1));
+  const columnWidth = count > 0 ? innerWidth / count : 0;
+  return { paddingX, paddingY, count, gap, width, height, columnWidth };
+}
+function sanitizeFlowContainer(container) {
+  return {
+    width: nonNegativeFinite(container.width, 0),
+    height: nonNegativeFinite(container.height, 0),
+    paddingX: container.paddingX === void 0 ? void 0 : nonNegativeFinite(container.paddingX, 0),
+    paddingY: container.paddingY === void 0 ? void 0 : nonNegativeFinite(container.paddingY, 0)
+  };
+}
+function sanitizeFlowColumns(columns) {
+  return {
+    count: columns.count === void 0 ? void 0 : Math.max(1, Math.floor(nonNegativeFinite(columns.count, 1))),
+    gap: columns.gap === void 0 ? void 0 : nonNegativeFinite(columns.gap, 0)
+  };
+}
+function sanitizeObstacles(obstacles) {
+  return obstacles.map((obstacle) => {
+    if (obstacle.kind === "circle") {
+      return {
+        kind: obstacle.kind,
+        cx: finiteNumber(obstacle.cx, 0),
+        cy: finiteNumber(obstacle.cy, 0),
+        r: nonNegativeFinite(obstacle.r, 0)
+      };
+    }
+    return {
+      kind: obstacle.kind,
+      x: finiteNumber(obstacle.x, 0),
+      y: finiteNumber(obstacle.y, 0),
+      width: nonNegativeFinite(obstacle.width, 0),
+      height: nonNegativeFinite(obstacle.height, 0)
+    };
+  });
+}
+function circleIntervalForBand(obstacle, bandTop, bandBottom) {
+  const radius = nonNegativeFinite(obstacle.r, 0);
+  const centerY = obstacle.cy;
+  const nearestY = Math.max(bandTop, Math.min(centerY, bandBottom));
+  const dy = nearestY - centerY;
+  if (Math.abs(dy) > radius) return null;
+  const dx = Math.sqrt(Math.max(0, radius * radius - dy * dy));
+  return { left: obstacle.cx - dx, right: obstacle.cx + dx };
+}
+function rectIntervalForBand(obstacle, bandTop, bandBottom) {
+  const left = obstacle.x;
+  const right = obstacle.x + nonNegativeFinite(obstacle.width, 0);
+  const top = obstacle.y;
+  const bottom = obstacle.y + nonNegativeFinite(obstacle.height, 0);
+  if (bottom <= bandTop || top >= bandBottom || right <= left) return null;
+  return { left, right };
+}
+function blockedIntervalsForBand(obstacles, bandTop, bandBottom) {
+  const intervals = [];
+  for (const obstacle of obstacles) {
+    const interval = obstacle.kind === "circle" ? circleIntervalForBand(obstacle, bandTop, bandBottom) : rectIntervalForBand(obstacle, bandTop, bandBottom);
+    if (interval) intervals.push(interval);
+  }
+  return intervals.sort((a, b) => a.left - b.left);
+}
+function computeFlowLines(segments, opts) {
+  const geometry = columnGeometry(opts.container, opts.columns);
+  const lineHeight = positiveFinite(opts.lineHeight, 20);
+  const minSlotWidth = nonNegativeFinite(opts.minSlotWidth ?? 0, 0);
+  const obstacles = opts.obstacles ?? [];
+  const segmentAdapter = opts.segmentAdapter ?? getDefaultSegmentAdapter();
+  const lines = [];
+  let cursor = { segmentIndex: 0, graphemeIndex: 0 };
+  const contentBottom = Math.max(geometry.paddingY, geometry.height - geometry.paddingY);
+  for (let columnIndex = 0; columnIndex < geometry.count; columnIndex += 1) {
+    const columnLeft = geometry.paddingX + columnIndex * (geometry.columnWidth + geometry.gap);
+    const columnRight = columnLeft + geometry.columnWidth;
+    for (let y = geometry.paddingY; y + lineHeight <= contentBottom + 1e-3 && cursor.segmentIndex < segments.length; y += lineHeight) {
+      const blocked = blockedIntervalsForBand(obstacles, y, y + lineHeight);
+      const slots = carveTextLineSlots(
+        { left: columnLeft, right: columnRight },
+        blocked,
+        Math.max(minSlotWidth, 1e-6)
+      );
+      for (const slot of slots) {
+        if (cursor.segmentIndex >= segments.length) break;
+        const slotWidth = slot.right - slot.left;
+        const next = layoutNextLine(segments, cursor, slotWidth, {
+          hyphenWidth: opts.hyphenWidth,
+          segmentAdapter
+        });
+        if (next === null) {
+          cursor = { segmentIndex: segments.length, graphemeIndex: 0 };
+          break;
+        }
+        if (next.end.segmentIndex === cursor.segmentIndex && next.end.graphemeIndex === cursor.graphemeIndex) {
+          break;
+        }
+        cursor = next.end;
+        if (next.text.length === 0 && next.width === 0) break;
+        lines.push({
+          text: next.text,
+          width: next.width,
+          startSegment: next.start.segmentIndex,
+          startGrapheme: next.start.graphemeIndex,
+          endSegment: next.end.segmentIndex,
+          endGrapheme: next.end.graphemeIndex,
+          x: slot.left,
+          y,
+          slotWidth,
+          columnIndex
+        });
+      }
+    }
+  }
+  return {
+    lines,
+    cursor,
+    done: cursor.segmentIndex >= segments.length
+  };
+}
+function reactiveLayout(opts) {
+  const { measurements, segmentAdapter: segmentAdapterOpt, name = "reactive-layout" } = opts;
+  const targetId = opts.targetId ?? "text";
+  const segAdapter = segmentAdapterOpt ?? getDefaultSegmentAdapter();
+  const g = opts.graph;
+  const lineHeightInput = inputNode(
+    g,
+    opts.lineHeight instanceof Node ? opts.lineHeight : nonNegativeFinite(opts.lineHeight ?? 20, 20),
+    nonNegativeFinite(20, 20),
+    scopedName(name, "line-height")
+  );
+  const maxWidthInput = inputNode(
+    g,
+    opts.maxWidth instanceof Node ? opts.maxWidth : nonNegativeFinite(opts.maxWidth ?? 800, 800),
+    nonNegativeFinite(800, 800),
+    scopedName(name, "max-width")
+  );
+  const segments = g.node(
+    [measurements],
+    (ctx) => {
+      try {
+        const measured = latestMeasurementValue(
+          depLatest(ctx, 0),
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND
+        );
+        ctx.down([["DATA", measured?.segments ?? []]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveLayout segments failed");
+      }
+    },
+    { name: scopedName(name, "segments") }
+  );
+  const lineBreaks = g.node(
+    [segments, maxWidthInput.node, measurements],
+    (ctx) => {
+      try {
+        const measured = latestMeasurementValue(
+          depLatest(ctx, 2),
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND
+        );
+        const computed = computeLineBreaks(
+          depLatest(ctx, 0),
+          nonNegativeFinite(depLatest(ctx, 1), 0),
+          { hyphenWidth: measured?.hyphenWidth, segmentAdapter: segAdapter }
+        );
+        ctx.down([["DATA", computed]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveLayout line breaks failed");
+      }
+    },
+    { name: scopedName(name, "line-breaks") }
+  );
+  const height = g.node(
+    [lineBreaks, lineHeightInput.node],
+    (ctx) => {
+      try {
+        const lines = depLatest(ctx, 0);
+        const lineHeight = nonNegativeFinite(depLatest(ctx, 1), 0);
+        ctx.down([["DATA", lines.lineCount * lineHeight]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveLayout height failed");
+      }
+    },
+    { name: scopedName(name, "height") }
+  );
+  const charPositions = g.node(
+    [lineBreaks, segments, lineHeightInput.node],
+    (ctx) => {
+      try {
+        const positions = computeCharPositions(
+          depLatest(ctx, 0),
+          depLatest(ctx, 1),
+          nonNegativeFinite(depLatest(ctx, 2), 0),
+          segAdapter
+        );
+        ctx.down([["DATA", positions]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveLayout char positions failed");
+      }
+    },
+    { name: scopedName(name, "char-positions") }
+  );
+  return {
+    graph: g,
+    input: {
+      lineHeight: lineHeightInput.node,
+      maxWidth: maxWidthInput.node,
+      measurements
+    },
+    setLineHeight(lineHeight) {
+      lineHeightInput.set(nonNegativeFinite(lineHeight, 0));
+    },
+    setMaxWidth(maxWidth) {
+      maxWidthInput.set(nonNegativeFinite(maxWidth, 0));
+    },
+    segments,
+    lineBreaks,
+    height,
+    charPositions
+  };
+}
+function reactiveBlockLayout(opts) {
+  const { measurements, name = "reactive-block-layout" } = opts;
+  const targetId = opts.targetId ?? "blocks";
+  const g = opts.graph;
+  const gapInput = inputNode(
+    g,
+    opts.gap instanceof Node ? opts.gap : nonNegativeFinite(opts.gap ?? 0, 0),
+    nonNegativeFinite(0, 0),
+    scopedName(name, "gap")
+  );
+  const measuredBlocks = g.node(
+    [measurements],
+    (ctx) => {
+      try {
+        const measured = latestMeasurementValue(
+          depLatest(ctx, 0),
+          targetId,
+          BLOCKS_MEASUREMENT_KIND
+        );
+        ctx.down([["DATA", measured?.blocks ?? []]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveBlockLayout measured-blocks failed");
+      }
+    },
+    { name: scopedName(name, "measured-blocks") }
+  );
+  const blockFlow = g.node(
+    [measuredBlocks, gapInput.node],
+    (ctx) => {
+      try {
+        const positioned = computeBlockFlow(
+          depLatest(ctx, 0),
+          nonNegativeFinite(depLatest(ctx, 1), 0)
+        );
+        ctx.down([["DATA", positioned]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveBlockLayout flow failed");
+      }
+    },
+    { name: scopedName(name, "block-flow") }
+  );
+  const totalHeight = g.node(
+    [blockFlow],
+    (ctx) => {
+      try {
+        ctx.down([["DATA", computeTotalHeight(depLatest(ctx, 0))]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveBlockLayout total height failed");
+      }
+    },
+    { name: scopedName(name, "total-height") }
+  );
+  return {
+    graph: g,
+    input: {
+      gap: gapInput.node,
+      measurements
+    },
+    setGap(gap) {
+      gapInput.set(nonNegativeFinite(gap, 0));
+    },
+    measuredBlocks,
+    blockFlow,
+    totalHeight
+  };
+}
+function reactiveFlowLayout(opts) {
+  const { measurements, segmentAdapter: segmentAdapterOpt, name = "reactive-flow-layout" } = opts;
+  const targetId = opts.targetId ?? "text";
+  const segAdapter = segmentAdapterOpt ?? getDefaultSegmentAdapter();
+  const g = opts.graph;
+  const lineHeightInput = inputNode(
+    g,
+    opts.lineHeight instanceof Node ? opts.lineHeight : nonNegativeFinite(opts.lineHeight ?? 20, 20),
+    nonNegativeFinite(20, 20),
+    scopedName(name, "line-height")
+  );
+  const containerInput = inputNode(
+    g,
+    opts.container,
+    { width: 800, height: 600 },
+    scopedName(name, "container")
+  );
+  const columnsInput = inputNode(
+    g,
+    opts.columns,
+    { count: 1, gap: 0 },
+    scopedName(name, "columns")
+  );
+  const obstaclesInput = inputNode(g, opts.obstacles, [], scopedName(name, "obstacles"));
+  const segments = g.node(
+    [measurements],
+    (ctx) => {
+      try {
+        const measured = latestMeasurementValue(
+          depLatest(ctx, 0),
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND
+        );
+        ctx.down([["DATA", measured?.segments ?? []]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveFlowLayout segments failed");
+      }
+    },
+    { name: scopedName(name, "segments") }
+  );
+  const flowLines = g.node(
+    [
+      segments,
+      lineHeightInput.node,
+      containerInput.node,
+      columnsInput.node,
+      obstaclesInput.node,
+      measurements
+    ],
+    (ctx) => {
+      try {
+        const measured = latestMeasurementValue(
+          depLatest(ctx, 5),
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND
+        );
+        const computed = computeFlowLines(depLatest(ctx, 0), {
+          lineHeight: nonNegativeFinite(depLatest(ctx, 1), 0),
+          container: sanitizeFlowContainer(depLatest(ctx, 2)),
+          columns: sanitizeFlowColumns(depLatest(ctx, 3)),
+          obstacles: sanitizeObstacles(depLatest(ctx, 4)),
+          minSlotWidth: nonNegativeFinite(opts.minSlotWidth ?? 0, 0),
+          hyphenWidth: measured?.hyphenWidth,
+          segmentAdapter: segAdapter
+        });
+        ctx.down([["DATA", computed]]);
+      } catch (error) {
+        emitLayoutError(ctx, error, "reactiveFlowLayout flow lines failed");
+      }
+    },
+    { name: scopedName(name, "flow-lines") }
+  );
+  return {
+    graph: g,
+    input: {
+      lineHeight: lineHeightInput.node,
+      container: containerInput.node,
+      columns: columnsInput.node,
+      obstacles: obstaclesInput.node,
+      measurements
+    },
+    setLineHeight(lineHeight) {
+      lineHeightInput.set(nonNegativeFinite(lineHeight, 0));
+    },
+    setContainer(container) {
+      containerInput.set(container);
+    },
+    setColumns(columns) {
+      columnsInput.set(columns);
+    },
+    setObstacles(obstacles) {
+      obstaclesInput.set(obstacles);
+    },
+    segments,
+    flowLines
+  };
+}
+
+export {
+  TEXT_SEGMENTS_MEASUREMENT_KIND,
+  BLOCKS_MEASUREMENT_KIND,
+  READINESS_MEASUREMENT_KIND,
+  IMAGE_SIZE_MEASUREMENT_KIND,
+  SVG_BOUNDS_MEASUREMENT_KIND,
+  InjectedMeasureAdapter,
+  PrecomputedMeasureAdapter,
+  CellMeasureAdapter,
+  CapabilityMeasureAdapter,
+  SvgBoundsAdapter,
+  ImageSizeAdapter,
+  textMeasurementProvider,
+  injectedTextMeasurements,
+  precomputedTextMeasurements,
+  cellTextMeasurements,
+  capabilityTextMeasurements,
+  readinessTextMeasurements,
+  readinessMeasurements,
+  imageSizeMeasurements,
+  svgBoundsMeasurements,
+  mergeMeasurements,
+  blockAdaptersProvider,
+  blockMeasurementProvider,
+  analyzeAndMeasure,
+  computeLineBreaks,
+  layoutNextLine,
+  carveTextLineSlots,
+  computeCharPositions,
+  measureBlock,
+  measureBlocks,
+  computeBlockFlow,
+  computeTotalHeight,
+  circleIntervalForBand,
+  rectIntervalForBand,
+  computeFlowLines,
+  reactiveLayout,
+  reactiveBlockLayout,
+  reactiveFlowLayout
+};
+//# sourceMappingURL=chunk-YXMZ2N6J.js.map