@graphrefly/graphrefly 0.24.0 → 0.26.0

package/dist/{chunk-TDEXAMGO.js → chunk-ZQMEI34O.js}

@@ -1,16 +1,26 @@
+import {
+  analyzeAndMeasure,
+  carveTextLineSlots,
+  computeCharPositions,
+  computeLineBreaks,
+  layoutNextLine,
+  reactiveLayout
+} from "./chunk-LCE3GF5P.js";
 import {
   emitToMeta
-} from "./chunk-HWPIFSW2.js";
+} from "./chunk-JSCT3CR4.js";
 import {
   Graph
-} from "./chunk-XOFWRC73.js";
+} from "./chunk-THTWHNU4.js";
 import {
-  __export,
   derived,
   monotonicNs,
   node,
   state
-} from "./chunk-5DJTTKX3.js";
+} from "./chunk-PHOUUNK7.js";
+import {
+  __export
+} from "./chunk-SX52TAR4.js";
 
 // src/patterns/reactive-layout/index.ts
 var reactive_layout_exports = {};
@@ -22,14 +32,20 @@ __export(reactive_layout_exports, {
   PrecomputedAdapter: () => PrecomputedAdapter,
   SvgBoundsAdapter: () => SvgBoundsAdapter,
   analyzeAndMeasure: () => analyzeAndMeasure,
+  carveTextLineSlots: () => carveTextLineSlots,
+  circleIntervalForBand: () => circleIntervalForBand,
   computeBlockFlow: () => computeBlockFlow,
   computeCharPositions: () => computeCharPositions,
+  computeFlowLines: () => computeFlowLines,
   computeLineBreaks: () => computeLineBreaks,
   computeTotalHeight: () => computeTotalHeight,
+  layoutNextLine: () => layoutNextLine,
   measureBlock: () => measureBlock,
   measureBlocks: () => measureBlocks,
   reactiveBlockLayout: () => reactiveBlockLayout,
-  reactiveLayout: () => reactiveLayout
+  reactiveFlowLayout: () => reactiveFlowLayout,
+  reactiveLayout: () => reactiveLayout,
+  rectIntervalForBand: () => rectIntervalForBand
 });
 
 // src/patterns/reactive-layout/measurement-adapters.ts
@@ -226,7 +242,7 @@ var CanvasMeasureAdapter = class {
       this.currentFont = font;
     }
     let width = ctx.measureText(text).width;
-    if (this.emojiCorrection !== 1 && /\p{Emoji_Presentation}/u.test(text)) {
+    if (this.emojiCorrection !== 1 && new RegExp("\\p{Emoji_Presentation}", "u").test(text)) {
       width *= this.emojiCorrection;
     }
     return { width };
@@ -310,569 +326,6 @@ var ImageSizeAdapter = class {
   }
 };
 
-// src/patterns/reactive-layout/reactive-layout.ts
-function isCJK(s) {
-  for (const ch of s) {
-    const c = ch.codePointAt(0);
-    if (c >= 19968 && c <= 40959 || // CJK Unified Ideographs
-    c >= 13312 && c <= 19903 || // CJK Extension A
-    c >= 12288 && c <= 12351 || // CJK Symbols and Punctuation
-    c >= 12352 && c <= 12447 || // Hiragana
-    c >= 12448 && c <= 12543 || // Katakana
-    c >= 44032 && c <= 55215 || // Hangul
-    c >= 65280 && c <= 65519) {
-      return true;
-    }
-  }
-  return false;
-}
-var kinsokuStart = /* @__PURE__ */ new Set([
-  "\uFF0C",
-  "\uFF0E",
-  "\uFF01",
-  "\uFF1A",
-  "\uFF1B",
-  "\uFF1F",
-  "\u3001",
-  "\u3002",
-  "\u30FB",
-  "\uFF09",
-  "\u3015",
-  "\u3009",
-  "\u300B",
-  "\u300D",
-  "\u300F",
-  "\u3011"
-]);
-var leftStickyPunctuation = /* @__PURE__ */ new Set([
-  ".",
-  ",",
-  "!",
-  "?",
-  ":",
-  ";",
-  ")",
-  "]",
-  "}",
-  "%",
-  '"',
-  "\u201D",
-  "\u2019",
-  "\xBB",
-  "\u203A",
-  "\u2026"
-]);
-function normalizeWhitespace(text) {
-  return text.replace(/[\t\n\r\f ]+/g, " ").replace(/^ | $/g, "");
-}
-function segmentText(normalized) {
-  const wordSegmenter = new Intl.Segmenter(void 0, { granularity: "word" });
-  const pieces = [];
-  for (const s of wordSegmenter.segment(normalized)) {
-    const text = s.segment;
-    const isWordLike = s.isWordLike ?? false;
-    const texts = [];
-    const wordLikes = [];
-    const kinds = [];
-    let currentText = "";
-    let currentKind = null;
-    for (const ch of text) {
-      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) {
-          texts.push(currentText);
-          wordLikes.push(currentKind === "text" && isWordLike);
-          kinds.push(currentKind);
-        }
-        currentText = ch;
-        currentKind = kind;
-      }
-    }
-    if (currentKind !== null) {
-      texts.push(currentText);
-      wordLikes.push(currentKind === "text" && isWordLike);
-      kinds.push(currentKind);
-    }
-    pieces.push({ texts, isWordLike: wordLikes, kinds });
-  }
-  return pieces;
-}
-function analyzeAndMeasure(text, font, adapter, cache, stats) {
-  const normalized = normalizeWhitespace(text);
-  if (normalized.length === 0) return [];
-  const pieces = segmentText(normalized);
-  const graphemeSegmenter = new Intl.Segmenter(void 0, {
-    granularity: "grapheme"
-  });
-  const rawTexts = [];
-  const rawKinds = [];
-  const rawWordLike = [];
-  for (const piece of pieces) {
-    for (let i = 0; i < piece.texts.length; i++) {
-      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++) {
-    const t = rawTexts[i];
-    const k = rawKinds[i];
-    const wl = rawWordLike[i];
-    if (k === "text" && !wl && mergedTexts.length > 0 && mergedKinds[mergedKinds.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);
-  }
-  let fontCache = cache.get(font);
-  if (!fontCache) {
-    fontCache = /* @__PURE__ */ new Map();
-    cache.set(font, fontCache);
-  }
-  function measureCached(seg) {
-    let w = fontCache.get(seg);
-    if (w === void 0) {
-      if (stats) stats.misses += 1;
-      w = adapter.measureSegment(seg, font).width;
-      fontCache.set(seg, w);
-    } else if (stats) {
-      stats.hits += 1;
-    }
-    return w;
-  }
-  const segments = [];
-  for (let i = 0; i < mergedTexts.length; i++) {
-    const t = mergedTexts[i];
-    const k = mergedKinds[i];
-    if (k !== "text") {
-      segments.push({
-        text: t,
-        width: k === "space" ? measureCached(" ") * t.length : 0,
-        kind: k,
-        graphemeWidths: null
-      });
-      continue;
-    }
-    if (isCJK(t)) {
-      let unitText = "";
-      for (const gs of graphemeSegmenter.segment(t)) {
-        const grapheme = gs.segment;
-        if (unitText.length > 0 && kinsokuStart.has(grapheme)) {
-          unitText += grapheme;
-          continue;
-        }
-        if (unitText.length > 0) {
-          const w2 = measureCached(unitText);
-          segments.push({
-            text: unitText,
-            width: w2,
-            kind: "text",
-            graphemeWidths: null
-          });
-        }
-        unitText = grapheme;
-      }
-      if (unitText.length > 0) {
-        const w2 = measureCached(unitText);
-        segments.push({
-          text: unitText,
-          width: w2,
-          kind: "text",
-          graphemeWidths: null
-        });
-      }
-      continue;
-    }
-    const w = measureCached(t);
-    let graphemeWidths = null;
-    if (mergedWordLike[i] && t.length > 1) {
-      const gWidths = [];
-      for (const gs of graphemeSegmenter.segment(t)) {
-        gWidths.push(measureCached(gs.segment));
-      }
-      if (gWidths.length > 1) {
-        graphemeWidths = gWidths;
-      }
-    }
-    segments.push({ text: t, width: w, kind: "text", graphemeWidths });
-  }
-  return segments;
-}
-function computeLineBreaks(segments, maxWidth, adapter, font, cache) {
-  if (segments.length === 0) {
-    return { lines: [], lineCount: 0 };
-  }
-  const lines = [];
-  let lineW = 0;
-  let hasContent = false;
-  let lineStartSeg = 0;
-  let lineStartGrapheme = 0;
-  let lineEndSeg = 0;
-  let lineEndGrapheme = 0;
-  let pendingBreakSeg = -1;
-  let pendingBreakWidth = 0;
-  let fontCache = cache.get(font);
-  if (!fontCache) {
-    fontCache = /* @__PURE__ */ new Map();
-    cache.set(font, fontCache);
-  }
-  let hyphenWidth = fontCache.get("-");
-  if (hyphenWidth === void 0) {
-    hyphenWidth = adapter.measureSegment("-", font).width;
-    fontCache.set("-", hyphenWidth);
-  }
-  function flushLine(endSeg = lineEndSeg, endGrapheme = lineEndGrapheme, width = lineW) {
-    let text = "";
-    for (let i = lineStartSeg; i < endSeg; i++) {
-      const seg = segments[i];
-      if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") continue;
-      if (i === lineStartSeg && lineStartGrapheme > 0 && seg.graphemeWidths) {
-        const graphemeSegmenter = new Intl.Segmenter(void 0, {
-          granularity: "grapheme"
-        });
-        const graphemes = [...graphemeSegmenter.segment(seg.text)].map((g) => g.segment);
-        text += graphemes.slice(lineStartGrapheme).join("");
-      } else {
-        text += seg.text;
-      }
-    }
-    if (endGrapheme > 0 && endSeg < segments.length) {
-      const seg = segments[endSeg];
-      const graphemeSegmenter = new Intl.Segmenter(void 0, {
-        granularity: "grapheme"
-      });
-      const graphemes = [...graphemeSegmenter.segment(seg.text)].map((g) => g.segment);
-      const startG = lineStartSeg === endSeg ? lineStartGrapheme : 0;
-      text += graphemes.slice(startG, endGrapheme).join("");
-    }
-    if (endSeg > 0 && segments[endSeg - 1]?.kind === "soft-hyphen" && !(lineStartSeg === endSeg && lineStartGrapheme > 0)) {
-      text += "-";
-    }
-    lines.push({
-      text,
-      width,
-      startSegment: lineStartSeg,
-      startGrapheme: lineStartGrapheme,
-      endSegment: endSeg,
-      endGrapheme
-    });
-    lineW = 0;
-    hasContent = false;
-    pendingBreakSeg = -1;
-    pendingBreakWidth = 0;
-  }
-  function canBreakAfter(kind) {
-    return kind === "space" || kind === "zero-width-break" || kind === "soft-hyphen";
-  }
-  function startLine(segIdx, graphemeIdx, width) {
-    hasContent = true;
-    lineStartSeg = segIdx;
-    lineStartGrapheme = graphemeIdx;
-    lineEndSeg = segIdx + 1;
-    lineEndGrapheme = 0;
-    lineW = width;
-  }
-  function startLineAtGrapheme(segIdx, graphemeIdx, width) {
-    hasContent = true;
-    lineStartSeg = segIdx;
-    lineStartGrapheme = graphemeIdx;
-    lineEndSeg = segIdx;
-    lineEndGrapheme = graphemeIdx + 1;
-    lineW = width;
-  }
-  for (let i = 0; i < segments.length; i++) {
-    const seg = segments[i];
-    if (seg.kind === "hard-break") {
-      if (hasContent) {
-        flushLine();
-      } else {
-        lines.push({
-          text: "",
-          width: 0,
-          startSegment: i,
-          startGrapheme: 0,
-          endSegment: i,
-          endGrapheme: 0
-        });
-      }
-      lineStartSeg = i + 1;
-      lineStartGrapheme = 0;
-      continue;
-    }
-    const w = seg.width;
-    if (!hasContent) {
-      if (w > maxWidth && seg.graphemeWidths) {
-        appendBreakableSegment(i, 0, seg.graphemeWidths);
-      } else {
-        startLine(i, 0, w);
-      }
-      if (canBreakAfter(seg.kind)) {
-        pendingBreakSeg = i + 1;
-        pendingBreakWidth = seg.kind === "space" ? lineW - w : lineW;
-      }
-      continue;
-    }
-    const newW = lineW + w;
-    if (newW > maxWidth + 5e-3) {
-      if (canBreakAfter(seg.kind)) {
-        lineW += w;
-        lineEndSeg = i + 1;
-        lineEndGrapheme = 0;
-        flushLine(i + 1, 0, seg.kind === "space" ? lineW - w : lineW);
-        continue;
-      }
-      if (pendingBreakSeg >= 0) {
-        flushLine(pendingBreakSeg, 0, pendingBreakWidth);
-        i--;
-        continue;
-      }
-      if (w > maxWidth && seg.graphemeWidths) {
-        flushLine();
-        appendBreakableSegment(i, 0, seg.graphemeWidths);
-        continue;
-      }
-      flushLine();
-      i--;
-      continue;
-    }
-    lineW = newW;
-    lineEndSeg = i + 1;
-    lineEndGrapheme = 0;
-    if (canBreakAfter(seg.kind)) {
-      pendingBreakSeg = i + 1;
-      pendingBreakWidth = seg.kind === "space" ? lineW - w : lineW;
-    }
-  }
-  if (hasContent) {
-    flushLine();
-  }
-  return { lines, lineCount: lines.length };
-  function appendBreakableSegment(segIdx, startG, gWidths) {
-    for (let g = startG; g < gWidths.length; g++) {
-      const gw = gWidths[g];
-      if (!hasContent) {
-        startLineAtGrapheme(segIdx, g, gw);
-        continue;
-      }
-      if (lineW + gw > maxWidth + 5e-3) {
-        flushLine();
-        startLineAtGrapheme(segIdx, g, gw);
-      } else {
-        lineW += gw;
-        lineEndSeg = segIdx;
-        lineEndGrapheme = g + 1;
-      }
-    }
-    if (hasContent && lineEndSeg === segIdx && lineEndGrapheme === gWidths.length) {
-      lineEndSeg = segIdx + 1;
-      lineEndGrapheme = 0;
-    }
-  }
-}
-function computeCharPositions(lineBreaks, segments, lineHeight) {
-  const positions = [];
-  const graphemeSegmenter = new Intl.Segmenter(void 0, {
-    granularity: "grapheme"
-  });
-  for (let lineIdx = 0; lineIdx < lineBreaks.lines.length; lineIdx++) {
-    const line = lineBreaks.lines[lineIdx];
-    const y = lineIdx * lineHeight;
-    let x = 0;
-    for (let si = line.startSegment; si < segments.length; si++) {
-      const seg = segments[si];
-      if (seg.kind === "soft-hyphen" || seg.kind === "hard-break") {
-        if (si >= line.endSegment && line.endGrapheme === 0) break;
-        continue;
-      }
-      const graphemes = [...graphemeSegmenter.segment(seg.text)].map((g) => g.segment);
-      if (graphemes.length === 0) continue;
-      const startG = si === line.startSegment ? line.startGrapheme : 0;
-      let endG;
-      if (si < line.endSegment) {
-        endG = graphemes.length;
-      } else if (si === line.endSegment && line.endGrapheme > 0) {
-        endG = line.endGrapheme;
-      } else {
-        break;
-      }
-      for (let g = startG; g < endG; g++) {
-        const gWidth = seg.graphemeWidths ? seg.graphemeWidths[g] : seg.width / graphemes.length;
-        positions.push({ x, y, width: gWidth, height: lineHeight, line: lineIdx });
-        x += gWidth;
-      }
-    }
-  }
-  return positions;
-}
-function reactiveLayout(opts) {
-  const { adapter, name = "reactive-layout" } = opts;
-  const g = new Graph(name);
-  const measureCache = /* @__PURE__ */ new Map();
-  const textNode = state(opts.text ?? "", { name: "text" });
-  const fontNode = state(opts.font ?? "16px sans-serif", {
-    name: "font"
-  });
-  const lineHeightNode = state(opts.lineHeight ?? 20, {
-    name: "line-height"
-  });
-  const maxWidthNode = state(Math.max(0, opts.maxWidth ?? 800), {
-    name: "max-width"
-  });
-  function graphemeWidthsEqual(a, b) {
-    if (a === null || b === null) return a === b;
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      if (a[i] !== b[i]) return false;
-    }
-    return true;
-  }
-  const segmentsNode = node(
-    [textNode, fontNode],
-    (data, actions, ctx) => {
-      const b0 = data[0];
-      const textVal = b0 != null && b0.length > 0 ? b0.at(-1) : ctx.prevData[0];
-      const b1 = data[1];
-      const fontVal = b1 != null && b1.length > 0 ? b1.at(-1) : ctx.prevData[1];
-      const t0 = monotonicNs();
-      const measureStats = { hits: 0, misses: 0 };
-      const result = analyzeAndMeasure(
-        textVal,
-        fontVal,
-        adapter,
-        measureCache,
-        measureStats
-      );
-      const elapsed = monotonicNs() - t0;
-      const lookups = measureStats.hits + measureStats.misses;
-      const hitRate = lookups === 0 ? 1 : measureStats.hits / lookups;
-      const meta = segmentsNode.meta;
-      if (meta) {
-        emitToMeta(meta["cache-hit-rate"], hitRate);
-        emitToMeta(meta["segment-count"], result.length);
-        emitToMeta(meta["layout-time-ns"], elapsed);
-      }
-      actions.emit(result);
-      return () => {
-        measureCache.clear();
-        adapter.clearCache?.();
-      };
-    },
-    {
-      name: "segments",
-      describeKind: "derived",
-      meta: {
-        "cache-hit-rate": 0,
-        "segment-count": 0,
-        "layout-time-ns": 0
-      },
-      equals: (a, b) => {
-        const sa = a;
-        const sb = b;
-        if (sa == null || sb == null) return sa === sb;
-        if (sa.length !== sb.length) return false;
-        for (let i = 0; i < sa.length; i++) {
-          const pa = sa[i];
-          const pb = sb[i];
-          if (pa.text !== pb.text || pa.width !== pb.width || pa.kind !== pb.kind || !graphemeWidthsEqual(pa.graphemeWidths ?? null, pb.graphemeWidths ?? null))
-            return false;
-        }
-        return true;
-      }
-    }
-  );
-  const lineBreaksNode = derived(
-    [segmentsNode, maxWidthNode, fontNode],
-    ([segs, mw, font]) => {
-      return computeLineBreaks(
-        segs,
-        mw,
-        adapter,
-        font,
-        measureCache
-      );
-    },
-    {
-      name: "line-breaks",
-      equals: (a, b) => {
-        const la = a;
-        const lb = b;
-        if (la == null || lb == null) return la === lb;
-        if (la.lineCount !== lb.lineCount) return false;
-        for (let i = 0; i < la.lines.length; i++) {
-          const lineA = la.lines[i];
-          const lineB = lb.lines[i];
-          if (lineA.text !== lineB.text || lineA.width !== lineB.width || lineA.startSegment !== lineB.startSegment || lineA.startGrapheme !== lineB.startGrapheme || lineA.endSegment !== lineB.endSegment || lineA.endGrapheme !== lineB.endGrapheme)
-            return false;
-        }
-        return true;
-      }
-    }
-  );
-  const heightNode = derived(
-    [lineBreaksNode, lineHeightNode],
-    ([lb, lh]) => lb.lineCount * lh,
-    { name: "height" }
-  );
-  const charPositionsNode = derived(
-    [lineBreaksNode, segmentsNode, lineHeightNode],
-    ([lb, segs, lh]) => {
-      return computeCharPositions(lb, segs, lh);
-    },
-    {
-      name: "char-positions",
-      equals: (a, b) => {
-        const ca = a;
-        const cb = b;
-        if (ca == null || cb == null) return ca === cb;
-        if (ca.length !== cb.length) return false;
-        for (let i = 0; i < ca.length; i++) {
-          if (ca[i].x !== cb[i].x || ca[i].y !== cb[i].y || ca[i].width !== cb[i].width)
-            return false;
-        }
-        return true;
-      }
-    }
-  );
-  g.add("text", textNode);
-  g.add("font", fontNode);
-  g.add("line-height", lineHeightNode);
-  g.add("max-width", maxWidthNode);
-  g.add("segments", segmentsNode);
-  g.add("line-breaks", lineBreaksNode);
-  g.add("height", heightNode);
-  g.add("char-positions", charPositionsNode);
-  return {
-    graph: g,
-    setText: (text) => g.set("text", text),
-    setFont: (font) => g.set("font", font),
-    setLineHeight: (lh) => g.set("line-height", lh),
-    setMaxWidth: (mw) => g.set("max-width", Math.max(0, mw)),
-    segments: segmentsNode,
-    lineBreaks: lineBreaksNode,
-    height: heightNode,
-    charPositions: charPositionsNode
-  };
-}
-
 // src/patterns/reactive-layout/reactive-block-layout.ts
 function measureBlock(block, maxWidth, adapters, measureCache, defaultFont, defaultLineHeight, index) {
   switch (block.type) {
@@ -1060,11 +513,186 @@ function reactiveBlockLayout(opts) {
   };
 }
 
+// src/patterns/reactive-layout/reactive-flow-layout.ts
+function circleIntervalForBand(o, bandTop, bandBottom) {
+  const hPad = o.hPad ?? 0;
+  const vPad = o.vPad ?? 0;
+  const top = bandTop - vPad;
+  const bottom = bandBottom + vPad;
+  if (top >= o.cy + o.r || bottom <= o.cy - o.r) return null;
+  const minDy = o.cy >= top && o.cy <= bottom ? 0 : o.cy < top ? top - o.cy : o.cy - bottom;
+  if (minDy >= o.r) return null;
+  const maxDx = Math.sqrt(o.r * o.r - minDy * minDy);
+  return { left: o.cx - maxDx - hPad, right: o.cx + maxDx + hPad };
+}
+function rectIntervalForBand(o, bandTop, bandBottom) {
+  const hPad = o.hPad ?? 0;
+  const vPad = o.vPad ?? 0;
+  if (bandBottom <= o.y - vPad) return null;
+  if (bandTop >= o.y + o.h + vPad) return null;
+  return { left: o.x - hPad, right: o.x + o.w + hPad };
+}
+function obstacleIntervalForBand(o, bandTop, bandBottom) {
+  return o.kind === "circle" ? circleIntervalForBand(o, bandTop, bandBottom) : rectIntervalForBand(o, bandTop, bandBottom);
+}
+function computeFlowLines(segments, container, columns, obstacles, lineHeight, minSlotWidth) {
+  const lines = [];
+  let cursor = { segmentIndex: 0, graphemeIndex: 0 };
+  if (segments.length === 0 || columns.count <= 0 || lineHeight <= 0) {
+    return { lines, cursor };
+  }
+  const padX = container.paddingX ?? 0;
+  const padY = container.paddingY ?? 0;
+  const availWidth = Math.max(0, container.width - padX * 2);
+  const availHeight = Math.max(0, container.height - padY * 2);
+  const gapTotal = columns.gap * Math.max(0, columns.count - 1);
+  const colWidth = Math.max(0, (availWidth - gapTotal) / columns.count);
+  if (colWidth <= 0) return { lines, cursor };
+  outerCol: for (let col = 0; col < columns.count; col++) {
+    const colLeft = padX + col * (colWidth + columns.gap);
+    const colRight = colLeft + colWidth;
+    let bandTop = padY;
+    while (bandTop + lineHeight <= padY + availHeight) {
+      const bandBottom = bandTop + lineHeight;
+      const blocked = [];
+      for (let oi = 0; oi < obstacles.length; oi++) {
+        const iv = obstacleIntervalForBand(obstacles[oi], bandTop, bandBottom);
+        if (iv !== null) blocked.push(iv);
+      }
+      const slots = carveTextLineSlots({ left: colLeft, right: colRight }, blocked, minSlotWidth);
+      if (slots.length === 0) {
+        bandTop += lineHeight;
+        continue;
+      }
+      let hardBreakThisBand = false;
+      for (let si = 0; si < slots.length; si++) {
+        const slot = slots[si];
+        const slotW = slot.right - slot.left;
+        const line = layoutNextLine(segments, cursor, slotW);
+        if (line === null) {
+          return { lines, cursor };
+        }
+        if (line.text.length === 0 && line.width === 0) {
+          cursor = line.end;
+          hardBreakThisBand = true;
+          break;
+        }
+        lines.push({
+          x: slot.left,
+          y: bandTop,
+          width: line.width,
+          slotWidth: slotW,
+          text: line.text,
+          columnIndex: col,
+          flushToRight: slot.right < colRight - 0.5
+        });
+        cursor = line.end;
+      }
+      bandTop += lineHeight;
+      if (hardBreakThisBand) continue;
+      if (cursor.segmentIndex >= segments.length) break outerCol;
+    }
+    if (cursor.segmentIndex >= segments.length) break;
+  }
+  return { lines, cursor };
+}
+function reactiveFlowLayout(opts) {
+  const { adapter, name = "reactive-flow-layout", minSlotWidth = 20 } = opts;
+  const g = new Graph(name);
+  const measureCache = /* @__PURE__ */ new Map();
+  const textNode = state(opts.text ?? "", { name: "text" });
+  const fontNode = state(opts.font ?? "16px sans-serif", { name: "font" });
+  const lineHeightNode = state(opts.lineHeight ?? 20, { name: "line-height" });
+  const containerNode = state(
+    opts.container ?? { width: 800, height: 600, paddingX: 0, paddingY: 0 },
+    { name: "container" }
+  );
+  const columnsNode = state(opts.columns ?? { count: 1, gap: 0 }, {
+    name: "columns"
+  });
+  const obstaclesNode = state(opts.obstacles ?? [], { name: "obstacles" });
+  const segmentsNode = node(
+    [textNode, fontNode],
+    (data, actions, ctx) => {
+      const b0 = data[0];
+      const textVal = b0 != null && b0.length > 0 ? b0.at(-1) : ctx.prevData[0];
+      const b1 = data[1];
+      const fontVal = b1 != null && b1.length > 0 ? b1.at(-1) : ctx.prevData[1];
+      const result = analyzeAndMeasure(textVal, fontVal, adapter, measureCache);
+      actions.emit(result);
+      return () => {
+        measureCache.clear();
+        adapter.clearCache?.();
+      };
+    },
+    { name: "segments", describeKind: "derived" }
+  );
+  const flowLinesNode = derived(
+    [segmentsNode, containerNode, columnsNode, obstaclesNode, lineHeightNode],
+    ([segs, cont, cols, obs, lh]) => {
+      const segments = segs;
+      const t0 = monotonicNs();
+      const { lines: result, cursor } = computeFlowLines(
+        segments,
+        cont,
+        cols,
+        obs,
+        lh,
+        minSlotWidth
+      );
+      const elapsed = monotonicNs() - t0;
+      const overflow = Math.max(0, segments.length - cursor.segmentIndex);
+      const meta = flowLinesNode.meta;
+      if (meta) {
+        emitToMeta(meta["line-count"], result.length);
+        emitToMeta(meta["layout-time-ns"], elapsed);
+        emitToMeta(meta["overflow-segments"], overflow);
+      }
+      return result;
+    },
+    {
+      name: "flow-lines",
+      meta: {
+        "line-count": 0,
+        "layout-time-ns": 0,
+        "overflow-segments": 0
+      },
+      equals: (a, b) => {
+        const la = a;
+        const lb = b;
+        if (la.length !== lb.length) return false;
+        for (let i = 0; i < la.length; i++) {
+          const pa = la[i];
+          const pb = lb[i];
+          if (pa.x !== pb.x || pa.y !== pb.y || pa.width !== pb.width || pa.slotWidth !== pb.slotWidth || pa.text !== pb.text || pa.columnIndex !== pb.columnIndex || pa.flushToRight !== pb.flushToRight)
+            return false;
+        }
+        return true;
+      }
+    }
+  );
+  g.add("text", textNode);
+  g.add("font", fontNode);
+  g.add("line-height", lineHeightNode);
+  g.add("container", containerNode);
+  g.add("columns", columnsNode);
+  g.add("obstacles", obstaclesNode);
+  g.add("segments", segmentsNode);
+  g.add("flow-lines", flowLinesNode);
+  return {
+    graph: g,
+    setText: (t) => g.set("text", t),
+    setFont: (f) => g.set("font", f),
+    setLineHeight: (lh) => g.set("line-height", lh),
+    setContainer: (c) => g.set("container", c),
+    setColumns: (c) => g.set("columns", c),
+    setObstacles: (o) => g.set("obstacles", o),
+    segments: segmentsNode,
+    flowLines: flowLinesNode
+  };
+}
+
 export {
-  analyzeAndMeasure,
-  computeLineBreaks,
-  computeCharPositions,
-  reactiveLayout,
   CliMeasureAdapter,
   PrecomputedAdapter,
   CanvasMeasureAdapter,
@@ -1076,6 +704,10 @@ export {
   computeBlockFlow,
   computeTotalHeight,
   reactiveBlockLayout,
+  circleIntervalForBand,
+  rectIntervalForBand,
+  computeFlowLines,
+  reactiveFlowLayout,
   reactive_layout_exports
 };
-//# sourceMappingURL=chunk-TDEXAMGO.js.map
+//# sourceMappingURL=chunk-ZQMEI34O.js.map