ooxml-core 1.1.0 → 1.2.1

package/dist/diagram/layout/smartart-layout-interpreter-composite-children.d.ts

@@ -0,0 +1,86 @@
+/**
+ * SmartArt DiagramML interpreter - composite child-repeater slot expansion.
+ *
+ * Split out of `smartart-layout-interpreter-composite.ts` to keep that file
+ * under the repo's per-file line budget: this half handles a bare-`presOf`
+ * composite slot (`Table List`'s `pillars`) whose own item TEMPLATE(s)
+ * address the anchor point's own CHILDREN rather than a `self`/`des` fold of
+ * the anchor itself, e.g. `pillar1`'s compound `presOf axis="ch desOrSelf"
+ * st="1 1" cnt="1 0"` (child #1, folding its own descendants) paired with a
+ * forEach-nested `pillarX` (`axis="desOrSelf"`, reached through a
+ * `dgm:forEach axis="ch" st="2"`: every remaining child, one box per
+ * position). Pure geometry; no framework code.
+ */
+import type { DiagramLayoutNode, DiagramNode } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { SlotStyleContext } from './smartart-layout-interpreter-composite.js';
+import type { SlottedDims } from './smartart-layout-interpreter-composite-slots.js';
+import type { BoundingBox, RenderedNode } from './smartart-layout-types.js';
+/** A uniform absolute pixel size every item from one repeater template takes. */
+export interface RepeaterItemSize {
+    width: number;
+    height: number;
+}
+/**
+ * Round 45: when `wrapper`'s own item template declares a bare `userS` `w`
+ * size reference (`radial-cluster--hier5.pptx`'s `childCenter1`/`text1`,
+ * `childCenter3`/`text3`, `childCenter2`/`text2` - identical shape across
+ * `cycle_1`/`cycle_2`/`cycle_3`, the SAME construct `resolveHubToNodeRatioViaUserSize`
+ * already resolves for a NESTED ring's hub/satellite ratio, see
+ * `smartart-layout-interpreter-cycle-hub-ratio-usersize.ts`), resolve the
+ * UNIFORM absolute pixel size every rendered item from that template takes,
+ * instead of `renderChildRepeaterSlot`'s pre-existing stretch-to-column
+ * sizing. This is what lets a childless satellite - never routed through
+ * `arrangeNestedCycleSlot`'s nested-cycle dispatch, since that requires the
+ * resolved item to have children of its own - still honour the SAME
+ * diagram-wide `userS` fact a nested satellite already does.
+ *
+ * Deliberately conservative: only applies when the template's own `h`
+ * constraint is the exact "square" shape observed in every fixture examined
+ * ({@link isSquareHeightConstraint}); any other shape leaves the caller's
+ * existing stretch-to-column sizing unchanged (`undefined`).
+ */
+export declare function resolveUserSizeItemBoxPx(wrapper: DiagramLayoutNode, index: ConstraintIndex, box: BoundingBox, sizeBox: BoundingBox, declaringRoleChain: readonly string[]): RepeaterItemSize | undefined;
+/** One resolved child-repeater box: which anchor-child it renders, and
+ * whether that child's own descendants fold into its text. */
+interface ChildRepeaterItem {
+    child: DiagramNode;
+    position: number;
+    fold: boolean;
+}
+/**
+ * Every box a bare-`presOf` wrapper slot (`Table List`'s `pillars`) produces
+ * for `anchor`'s own children, across ALL of the wrapper's item templates
+ * (`pillar1` AND `pillarX`), sorted into child order. Empty when the wrapper
+ * has no such template (a purely decorative slot, e.g. `base`).
+ *
+ * Exported (ROUND 42) for `smartart-layout-interpreter-composite-nested-
+ * cycle.ts`'s `resolveNestedCycleAnchor`, which reuses this exact resolution
+ * to detect a genuine 2-level nested hub-and-satellite ring
+ * (`radial-cluster--hier5.pptx`'s `cycle_3`) rather than a flat per-child
+ * repeat.
+ */
+export declare function collectChildRepeaterItems(wrapper: DiagramLayoutNode, anchorChildren: DiagramNode[]): ChildRepeaterItem[];
+/** Ancestor context {@link resolveUserSizeItemBoxPx} needs, threaded down from
+ * `arrangeComposite` (round 45) - omit (the pre-existing default) for a
+ * caller with no `ConstraintIndex`/ancestor chain to offer, e.g. a unit test
+ * exercising the plain stretch-to-column path. */
+export interface RepeaterSizingContext {
+    index: ConstraintIndex;
+    sizeBox: BoundingBox;
+    declaringRoleChain: readonly string[];
+}
+/**
+ * Render a bare-`presOf` wrapper slot as a repeated per-child list against
+ * `anchor`'s own children (see {@link collectChildRepeaterItems}), splitting
+ * the wrapper's own resolved rect into equal columns in child order. Each
+ * item stretches to fill its own column UNLESS {@link resolveUserSizeItemBoxPx}
+ * resolves a `userS`-declared uniform size for the wrapper's own item
+ * template (round 45) - then the item takes that fixed size instead, centred
+ * within its column (clamped to the column/rect extent so it never overlaps
+ * a sibling). Returns `[]` when the wrapper resolves no items (nothing to
+ * render).
+ */
+export declare function renderChildRepeaterSlot(wrapperSlot: SlottedDims, anchor: DiagramNode, anchorIndex: number, box: BoundingBox, absX: number, absY: number, childrenOf: Map<string, DiagramNode[]>, ctx: SlotStyleContext, sizingCtx?: RepeaterSizingContext): RenderedNode[];
+export {};
+//# sourceMappingURL=smartart-layout-interpreter-composite-children.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-composite-children.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-children.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-children.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAEhF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAKjF,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAoB,MAAM,yBAAyB,CAAC;AAG3F,iFAAiF;AACjF,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAcD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CACvC,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,WAAW,EACpB,kBAAkB,EAAE,SAAS,MAAM,EAAE,GACnC,gBAAgB,GAAG,SAAS,CAyB9B;AAyCD;8DAC8D;AAC9D,UAAU,iBAAiB;IAC1B,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;CACd;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACxC,OAAO,EAAE,iBAAiB,EAC1B,cAAc,EAAE,WAAW,EAAE,GAC3B,iBAAiB,EAAE,CAgBrB;AAED;;;kDAGkD;AAClD,MAAM,WAAW,qBAAqB;IACrC,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,WAAW,CAAC;IACrB,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACtC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,WAAW,EACnB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,GAAG,EAAE,gBAAgB,EACrB,SAAS,CAAC,EAAE,qBAAqB,GAC/B,YAAY,EAAE,CA0ChB"}

package/dist/diagram/layout/smartart-layout-interpreter-composite-choose-groups.d.ts

@@ -0,0 +1,44 @@
+/**
+ * SmartArt DiagramML interpreter - `dgm:choose` first-match-wins group
+ * resolution.
+ *
+ * `smartart-layout-definition.ts`'s `nestedLayoutNodes` flattens every
+ * `dgm:choose` branch onto its parent `layoutNode`'s own `.children`
+ * unconditionally (never evaluating conditions at parse time), so a real
+ * ECMA-376 `dgm:choose` - "evaluate each `dgm:if` in order, the FIRST whose
+ * condition holds wins, siblings never coexist" - becomes an ordinary flat
+ * sibling list once parsed. `smartart-layout-interpreter-composite-
+ * choose.ts`'s `collectRawCandidates` used to treat every choose-flattened
+ * sibling as an INDEPENDENT candidate (each checked only against its own
+ * `chooseGuard` AND-chain), which is correct for a genuinely independent
+ * set of guarded slots (`cycle-matrix`'s `child1group`..`child4group`, each
+ * gated on a DIFFERENT top-level point) but wrong for a MUTUALLY EXCLUSIVE
+ * family: `balance--hier5.pptx`'s `balance_NN`/`left_NN_M`/`right_NN_M`
+ * (127 members across ~30 nested `dgm:choose` instances) describes ONE
+ * "pick exactly one arrangement" decision tree, and evaluating every branch
+ * independently can leave SEVERAL simultaneously "live" when the real
+ * DiagramML semantics wants exactly one.
+ *
+ * {@link selectFirstMatchChildren} recovers the real semantics from
+ * `DiagramLayoutNode.chooseGroups` (populated during flattening - see
+ * that field's own doc comment): for every distinct `dgm:choose` GROUP
+ * reachable from a list of siblings, keep only the LOWEST-ordinal member
+ * whose own branch condition holds (an `dgm:else` entry, `guard`
+ * `undefined`, always holds when reached - it is the fallback), and drop
+ * every other member of that SAME group (and, since filtering runs BEFORE
+ * the caller recurses into a dropped sibling's own subtree, everything
+ * nested inside it too). A sibling with NO `chooseGroups` at all (never
+ * reached through a `dgm:choose`) is always kept, unaffected.
+ *
+ * Pure TypeScript - no framework code, no DOM.
+ */
+import type { DiagramLayoutNode, DiagramNode } from '../model/index.js';
+/**
+ * Filter `children` to first-match-wins survivors - see this module's own
+ * doc comment. A fast, allocation-free no-op when none of `children` carries
+ * `chooseGroups` at all (every fixture NOT shaped like `balance`'s own
+ * mutually-exclusive family), so every pre-existing caller/fixture is
+ * byte-for-byte unaffected.
+ */
+export declare function selectFirstMatchChildren(children: DiagramLayoutNode[], flat: DiagramNode[]): DiagramLayoutNode[];
+//# sourceMappingURL=smartart-layout-interpreter-composite-choose-groups.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-composite-choose-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-choose-groups.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-choose-groups.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EACX,iBAAiB,EACjB,WAAW,EAGX,MAAM,UAAU,CAAC;AAqDlB;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,IAAI,EAAE,WAAW,EAAE,GACjB,iBAAiB,EAAE,CA+BrB"}

package/dist/diagram/layout/smartart-layout-interpreter-composite-choose.d.ts

@@ -0,0 +1,109 @@
+/**
+ * SmartArt DiagramML interpreter - `dgm:choose`-guarded composite slot
+ * resolution.
+ *
+ * A composite whose own `.children` include NO `self`-axis slot at all
+ * (`cycle-matrix`/`balance`'s shape: the WHOLE composite tree has no single
+ * bound "current point", so every content-bearing slot's `dgm:presOf`
+ * resolves relative to the DIAGRAM ROOT, exactly like a diagram-level
+ * `dgm:choose` condition) needs a DIFFERENT slot-collection strategy than
+ * `arrangeByPresentationOf`'s self/des ordinal matching (`smartart-layout-
+ * interpreter-composite.ts`).
+ *
+ * `cycle-matrix--fallback-n2.pptx`'s real shape: `children` (a bare wrapper,
+ * no presOf) flattens FOUR named groups (`child1group`..`child4group`), each
+ * gated by its OWN `dgm:if` (`axis="ch ch" ptType="node node" st="N 1"
+ * cnt="1 0" func="cnt" op="gte" val="1"` - "does top-level point N exist AND
+ * have >= 1 child of its own"), unconditionally flattened onto `.children`
+ * by `smartart-layout-definition.ts`'s `nestedLayoutNodes` (which does not
+ * evaluate `dgm:choose` conditions) but tagged with the guarding `dgm:if`'s
+ * condition as `chooseGuard`. A LIVE group's own children (`child1`/
+ * `child1Text`, compound `presOf axis="ch des" st="1 1" cnt="1 0"`) resolve
+ * relative to the SAME diagram root, not to any per-group anchor - "take
+ * top-level point 1, then ITS descendants". A SIBLING top-level bare wrapper
+ * (`circle`, guarded the SAME way as `children`) can ALSO be live at once -
+ * its own children (`quadrant1..4`) carry a plain single-token `presOf
+ * axis="ch"`, each independently positioned into the diagram's own top-level
+ * point list by its own `st`/`cnt` (`quadrant1`: position 1 = the diagram's
+ * first top-level point itself).
+ *
+ * A DIFFERENT shape needs the OPPOSITE resolution: `Phased Process`'s
+ * `middleComposite`/`leftComposite` (bare wrappers, each scoped to one
+ * specific phase) nest a per-position `dgm:forEach axis="ch ch" st="N M"
+ * cnt="1 1"` around each of THEIR OWN content children (`circ1Tx`, `presOf
+ * axis="desOrSelf"` - a single-token axis that only makes sense relative to
+ * an anchor, never the whole diagram). `resolveAnchoredContent`
+ * (`smartart-layout-interpreter-composite-anchor.ts`) is what tells the two
+ * shapes apart: it resolves a node's `presOf` relative to its OWN
+ * `forEachOrigin` (the enclosing forEach's own resolved point) when one is
+ * present, and relative to the diagram root otherwise - see its own doc
+ * comment for the full derivation.
+ *
+ * Pure geometry; no framework code.
+ */
+import type { DiagramLayoutNode, DiagramNode } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { SlotStyleContext } from './smartart-layout-interpreter-composite.js';
+import type { FontFitContext } from './smartart-layout-interpreter-composite-fontfit.js';
+import type { ChooseAwareSlot } from './smartart-layout-interpreter-composite-group-slots.js';
+import type { BoundingBox, RenderedNode } from './smartart-layout-types.js';
+/**
+ * Collect every choose-live content slot in `node`'s subtree (see
+ * {@link collectRawCandidates}, `smartart-layout-interpreter-composite-
+ * candidates.ts`, for the recursive walk this wraps), merging
+ * candidates that resolve to the SAME point set into ONE slot rather than
+ * one per layoutNode.
+ *
+ * `Basic Venn`'s `circ1` (`dgm:alg type="sp"`, decorative) and `circ1Tx`
+ * (`alg="tx"`, the real text) share the exact SAME `forEachOrigin` anchor,
+ * so both resolve to the SAME content - without merging, that content would
+ * be folded in TWICE (`PRIMARY_ALG` maps `sp` to `'spacer'` elsewhere in
+ * this interpreter for the same reason: it is never a text family on its
+ * own). Merging also RECOVERS geometry a text-only member lacks: `Staggered
+ * Process`'s `ThreeNodes_3_text` (`hideGeom`) has no `readSlots`-resolvable
+ * constraint of its own at all; only its decorative `ThreeNodes_3` sibling
+ * does, and dropping `sp` candidates outright (an earlier, simpler version
+ * of this fix) lost that geometry along with the duplicate, silently
+ * dropping the whole slot instead of just de-duplicating it.
+ */
+export declare function collectChooseAwareSlots(node: DiagramLayoutNode, flat: DiagramNode[], box: BoundingBox, index: ConstraintIndex, declaringRole: string): ChooseAwareSlot[];
+/**
+ * `dgm:choose`-guarded root-relative slot collection, for a composite with NO
+ * `self`-axis slot anywhere (`cycle-matrix`/`balance`'s shape - see this
+ * module's own doc comment). Returns `undefined` when nothing resolves, so
+ * the caller (`smartart-layout-interpreter-composite.ts`) falls back to the
+ * blind order-based mapping.
+ *
+ * Round 28 measured a shared-font-fit wiring attempt (`resolveSharedFontFit`
+ * across EVERY slot at once, matching the OTHER two composite paths) against
+ * the full 227-fixture corpus and REVERTED it: it genuinely helped several
+ * fixtures close to the cached size (`balance--hier5.pptx` 12->34.7pt
+ * against a 37.3pt target, `counterbalance-arrows--fallback-n2.pptx`
+ * 12->34.7pt against 36.0pt), but OVERSHOT others badly
+ * (`cycle-matrix--fallback-n2.pptx` 12->80.0pt against a 21.3pt target,
+ * `grid-matrix--fallback-n1.pptx` 12->110.7pt against 61.3pt,
+ * `segmented-pyramid--hier5.pptx` 12->86.7pt against 25.3pt), because
+ * `slots[0]?.node`'s own declared `primFontSz` ceiling was reused as ONE
+ * SHARED ceiling for every slot in the whole composite - but this family's
+ * slots do NOT always share one uniform item template the way
+ * `upward-arrow`'s own `arrowDiagramN`/`textBoxN` count-branches do (all
+ * discovered under the SAME live count-branch wrapper): a
+ * `cycle-matrix`/`basic-matrix`/`segmented-pyramid`-style choose-aware
+ * composite's slots come from DIFFERENT named wrapper groups
+ * (`child1group` vs `circle`, etc.), each with its own genuinely different
+ * declared ceiling.
+ *
+ * Round 29: fit is now computed PER GROUP instead of once globally, keyed by
+ * `ChooseAwareSlot.declaringRole` (the name of the nearest enclosing
+ * bare-wrapper `layoutNode` each slot was discovered under, already threaded
+ * through by `resolveGroupedSlots`). `upward-arrow`'s slots all share ONE
+ * declaringRole (their live count-branch wrapper), so grouping degenerates
+ * to the SAME single shared fit round 28 already measured as correct for it;
+ * `cycle-matrix`/`grid-matrix`/`segmented-pyramid`'s slots split across
+ * their own distinct wrapper names, so each group gets its own ceiling
+ * instead of inheriting an unrelated group's. Measured monotonic (no
+ * fixture's `maxGeomDelta` worse) across the full corpus before landing -
+ * see the round 29 update in the successor doc for the exact sweep.
+ */
+export declare function arrangeByChooseAwareSlots(root: DiagramLayoutNode, flat: DiagramNode[], box: BoundingBox, index: ConstraintIndex, ctx: SlotStyleContext, fontCtx?: FontFitContext): RenderedNode[] | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-composite-choose.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-composite-choose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-choose.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-choose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAEhF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AAEtF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qDAAqD,CAAC;AAI3F,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAoB,MAAM,yBAAyB,CAAC;AAE3F;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,WAAW,EAAE,EACnB,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,MAAM,GACnB,eAAe,EAAE,CAGnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,yBAAyB,CACxC,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,WAAW,EAAE,EACnB,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,gBAAgB,EACrB,OAAO,CAAC,EAAE,cAAc,GACtB,YAAY,EAAE,GAAG,SAAS,CA+B5B"}

package/dist/diagram/layout/smartart-layout-interpreter-composite-detect.d.ts

@@ -0,0 +1,182 @@
+/**
+ * SmartArt DiagramML interpreter - top-level `composite` arranger detection.
+ *
+ * Split out of `smartart-layout-interpreter-model.ts` (the repo's per-file
+ * line budget) so `discoverArrangement` can tell a genuine top-level
+ * `composite` arranger (`gear`, `balance`, `stacked-venn`) apart from a
+ * per-item composite item TEMPLATE (Meet the Team's `compNode`) without
+ * hijacking the diagram's real structural arranger. Pure TypeScript - no
+ * framework code, no DOM.
+ */
+import type { DiagramLayoutNode } from '../model/index.js';
+/**
+ * True when a composite's child `layoutNode`s carry positioning constraints that
+ * map data points into fixed slots. Only then does `composite` win; otherwise it
+ * is a passive wrapper and the interpreter recurses to the inner arrangement.
+ *
+ * Checks TWO shapes real built-ins use: a slot positioning ITSELF (its own
+ * `constrLst` carries `l`/`t`/`w`/`h`/`ctrX`/`ctrY`), and the far more common
+ * one - the composite ARRANGER positioning its slots FOR them, via its own
+ * `for="ch" forName="<slot>"` constraint (`gear`, `balance`, `stacked-venn`;
+ * see `allConstraints`, which also reaches a slot list nested inside a
+ * `dgm:choose`/`dgm:forEach` the composite's positioning is count-branched
+ * by - `gear`'s blocker).
+ */
+/** `dgm:alg` types that are a genuine structural arranger, never a plain content leaf. */
+export declare const STRUCTURAL_ALG_TYPES: Set<string>;
+/**
+ * True when `node` was reached through an ENCLOSING `dgm:forEach` that only
+ * ever iterates TRANSITION points (`axis="followSib"`, or `ptType`
+ * restricted to `sibTrans`/`parTrans`) - a decorative connector/spacer
+ * between two arranged points, never the diagram's own repeated content.
+ * `hProcess7` ("Detailed Process")'s `vProcSp` reuses the SAME `dgm:alg
+ * type="lin"` as the diagram's real per-item arranger, purely to line up its
+ * OWN three decorative sub-shapes (`vSp1`/`simulatedConn`/`vSp2`, a simulated
+ * connector) - it is a flattened SIBLING of the genuine item template
+ * (`compositeNode`) within the arranger's own `.children`, reached via
+ * `forEach axis="followSib" ptType="sibTrans"`, so a plain "first child whose
+ * algorithm type matches" search picks it BEFORE ever considering the real
+ * arranger, hijacking `discoverArrangement`'s choose-decided `linear` plan
+ * into laying out three decorative slivers instead of the diagram's actual
+ * items (measured: 3 slivers where 3 real item cards were expected). Moved
+ * here (from `smartart-layout-interpreter-model.ts`, its only caller) purely
+ * for the repo's per-file line budget.
+ */
+export declare function isTransitionOnlyChild(node: DiagramLayoutNode): boolean;
+/**
+ * True when `node` declares its OWN `dgm:forEach axis="ch" st="N"` with
+ * `N > 1` - a CONTINUATION iterator picking up from an EARLIER point already
+ * consumed elsewhere in the SAME item template (`Table List`'s `pillars`
+ * `st="2"`, skipping the composite's own `roof` slot which separately
+ * consumes point 1; `Stacked List`'s `vertFlow` `st="2"`, skipping the
+ * `firstComp` slot's own point 1), never the diagram's own top-level
+ * "repeat once per point starting from the first" driver. Used by both
+ * `discoverArrangement` (`smartart-layout-interpreter-model.ts`, to exclude
+ * a continuation arranger from STRUCTURAL candidacy so the walk keeps
+ * looking for the real one) and {@link hasStructuralDescendant} below (to
+ * exclude it from disqualifying an OUTER composite too - the deferral
+ * `hasStructuralDescendant` exists for is correct for a genuine per-item
+ * nested arranger like `NumberedDotsVertical`'s `itemsFlow` - `st="1"`/
+ * absent - but wrong for a continuation that only ever covers PART of the
+ * points).
+ *
+ * Requires EVERY `forEach` entry to qualify (`.every`, not `.some`) - a node
+ * can carry SEVERAL independent `axis="ch"` `forEach` entries at once, one
+ * per named alternative slot (`Basic Venn`'s root `compositeShape`: seven
+ * single-point entries, `st="1"` through `st="7"`, one per possible circle -
+ * see ECMA-376 21.4.4.9, `dgm:forEach` is repeatable). A `.some` match
+ * wrongly branded `compositeShape` a "continuation" because SIX of its seven
+ * entries start beyond point 1, even though the SEVENTH (`st` absent, i.e.
+ * `1`) covers point 1 - `discoverArrangement` then excluded the composite
+ * root from choose/structural candidacy entirely, falling through to the
+ * last-resort single-leaf `tx` plan (measured: `basic-venn`/`hexagon-
+ * cluster`/`theme-picture-accent`/`theme-picture-grid`/`theme-picture-
+ * alternating-accent` all landed on `plan.kind: 'text'` this way). A GENUINE
+ * continuation (`Table List`'s `pillars`, `Stacked List`'s `vertFlow`)
+ * declares exactly ONE such `forEach`, so `.every` agrees with the old
+ * `.some` there (a single-element array), and an empty array (no `forEach`
+ * at all) is guarded separately so `.every`'s vacuous-true default never
+ * fires.
+ */
+export declare function isContinuationForEach(node: DiagramLayoutNode): boolean;
+/**
+ * True when `node` has a DESCENDANT whose OWN `dgm:alg` is a structural type
+ * (`lin`/`cycle`/`pyra`/`snake`/`hierRoot`/`hierChild`, checked via a DIRECT,
+ * non-choose-wrapped algorithm only - `parseSmartArtLayoutAlgorithm` parses
+ * `algorithm` as `undefined` for a choose-wrapped one, so this never fires
+ * for that shape, which is fine: a choose-DECIDED composite branch is
+ * already handled by `discoverArrangement`'s separate choose-resolution
+ * path, an active decision this passive check should not second-guess).
+ * Excludes a descendant that is itself only a {@link isContinuationForEach}
+ * arranger (see its own doc comment) - such a descendant covers only PART of
+ * the points, so it must not disqualify the outer composite from ALSO being
+ * considered.
+ *
+ * A composite whose sole mapped slot IS a nested structural arranger is a
+ * passive positioning SHELL, not a genuine top-level composite -
+ * `NumberedDotsVertical`'s `root` wraps `itemsFlow`'s own direct `dgm:alg
+ * type="lin"` (no `dgm:choose` at all) purely to position it inside a single
+ * named slot; `mapsSlots(root)` sees that ONE `for="ch" forName="itemsFlow"`
+ * constraint and returns `true`, so without this exclusion
+ * `discoverArrangement`'s composite-over-structural priority hijacked the
+ * diagram away from its real `linear`/`itemsFlow` arrangement into a
+ * degenerate single-slot "composite" (one item, no repetition at all) -
+ * measured as a generic grid-fallback shape instead of the real item flow.
+ * A GENUINE composite (`gear`, `balance`, `stacked-venn`) maps its slots onto
+ * plain content leaves (`tx`/`sp`/`conn`), never onto a nested `lin`/`cycle`/
+ * `pyra`/`snake`/hierarchy alg, so this never excludes one of those.
+ */
+export declare function hasStructuralDescendant(node: DiagramLayoutNode): boolean;
+/**
+ * True when `node` has a structural descendant (as {@link
+ * hasStructuralDescendant}) that is ALSO reached through a genuine
+ * "repeated per-point item template" `forEachOrigin` (`axis="ch"
+ * ptType="node"` - the same narrow signal `smartart-layout-interpreter-
+ * composite-candidates.ts`'s `collectRawCandidates` uses to establish an
+ * inheritable anchor, round 32). This is the signal the round 31/32 multi-
+ * slot `compositeSlot` exception (`smartart-layout-interpreter-model.ts`)
+ * needs: `continuous-arrow-process--hier5.pptx`'s `linV` matches (reached
+ * via `linH`'s own `dgm:forEach`), so its outer `Name0` composite correctly
+ * gets a chance to resolve `linV`'s per-point content through the slot
+ * resolver. `NumberedDotsVertical`'s `itemsFlow` does NOT match (it owns
+ * its OWN `dgm:forEach` directly - `node.forEach`, not `forEachOrigin` - as
+ * a plain top-level-shaped structural arranger, not something reached
+ * through an enclosing one), so `root` stays excluded exactly as {@link
+ * hasStructuralDescendant}'s own doc comment describes: `structural` (the
+ * EXISTING `linear`/`itemsFlow` pick, already correctly expanded by
+ * `smartart-layout-interpreter-item-roles.ts`) must keep winning for that
+ * shape, not the composite slot resolver, which does not yet handle a
+ * nested COMPOSITE item template (`item`, `alg="composite"`, excluded from
+ * `STRUCTURAL_ALG_TYPES` on purpose - only `lin`/`cycle`/`pyra`/`snake`
+ * item templates are handled today).
+ */
+export declare function hasRepeatedTemplateStructuralDescendant(node: DiagramLayoutNode): boolean;
+/**
+ * Count of DISTINCT slot names `node` positions via its own `for="ch"
+ * forName="<slot>"` constraints (`node.allConstraints`) - round 31/32's
+ * signal for telling a composite with exactly ONE convenience-wrapped
+ * structural child (`NumberedDotsVertical`'s `root`/`itemsFlow` shell,
+ * `hasStructuralDescendant`'s own doc comment) apart from one with SEVERAL
+ * independent slots, one of which happens to also have a structural
+ * descendant (`continuous-arrow-process--hier5.pptx`'s `Name0`: `dummy` +
+ * `linH`, TWO distinct slots, `radial-cluster--hier5.pptx`'s `Name0`:
+ * `textCenter` + `cycle_1..7`, EIGHT). A shell names exactly one slot; a
+ * genuine multi-slot composite whose slots happen to include a structural
+ * arranger still needs `compositeSlot` to win so the slot resolver (not a
+ * blind "first structural descendant wins" walk) decides what renders.
+ */
+export declare function distinctMappedSlotCount(node: DiagramLayoutNode): number;
+export declare function mapsSlots(node: DiagramLayoutNode): boolean;
+/**
+ * Composite nodes that are the REPEATED item template of an outer
+ * `forEach axis="ch" ptType="node"` (Meet the Team's `compNode`, Text Card's
+ * `compNode`, Step Down Process's `composite`), as opposed to a genuine
+ * top-level composite arranger mapping DISTINCT data points onto named
+ * slots (`gear`, `balance`, `stacked-venn`).
+ *
+ * `mapsSlots` also recognises ARRANGER-declared slot constraints (`for="ch"
+ * forName="<slot>"`), which a per-item composite always carries too (its
+ * own `photoCircle`/`nameText`/... positioning) - without this exclusion,
+ * `discoverArrangement`'s composite-over-structural priority would hijack
+ * every per-item-composite layout away from its correctly found `lin`/
+ * `snake`/`cycle`/`pyra` structural arranger, SINCE such a composite is
+ * always `itemNode(arranger)` (the arranger's own FIRST child) and
+ * `smartart-layout-interpreter-item-roles.ts`'s wrapper-drilling already
+ * handles it there. A genuine top-level composite is never itself such an
+ * item template (nothing repeats it per point), so it is unaffected.
+ */
+export declare function itemTemplateNodes<R>(node: DiagramLayoutNode<R>, out: Set<DiagramLayoutNode<R>>): void;
+/**
+ * True when `node` is `ancestor` itself, or somewhere inside its subtree.
+ * `discoverArrangement` (`smartart-layout-interpreter-model.ts`) uses this
+ * to keep a SIBLING alternative slot (`nested-target--hier5.pptx`'s
+ * `middleBox`/`centerBox`, each flattened onto the SAME parent's children
+ * the way `outerBox` is, each with its OWN separate, shallow-resolving
+ * nested `.choose`) from independently re-asserting a whole-diagram
+ * algorithm pick once an ANCESTOR composite has already been found to have
+ * ITS OWN choose wrongly tunnelling into one such slot - see
+ * `smartart-layout-interpreter-choose-depth.ts`'s own doc comment for the
+ * full derivation.
+ */
+export declare function isLayoutNodeOrDescendantOf(ancestor: DiagramLayoutNode, node: DiagramLayoutNode): boolean;
+//# sourceMappingURL=smartart-layout-interpreter-composite-detect.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-composite-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-detect.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAKlD;;;;;;;;;;;;GAYG;AACH,0FAA0F;AAC1F,eAAO,MAAM,oBAAoB,aAO/B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAatE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAQtE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAMxE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,uCAAuC,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAYxF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAQvE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAU1D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAClC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC1B,GAAG,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAC5B,IAAI,CAcN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACzC,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,iBAAiB,GACrB,OAAO,CAKT"}

package/dist/diagram/layout/smartart-layout-interpreter-composite-fontfit.d.ts

@@ -0,0 +1,60 @@
+/**
+ * SmartArt DiagramML interpreter - shared font-fit wiring for the
+ * `composite` arranger.
+ *
+ * Split out of `smartart-layout-interpreter-composite.ts` (the repo's
+ * per-file line budget).
+ *
+ * Round 18: a `composite` arranger used to never call the shared font-fit
+ * at all - every item fell through `rectNode`'s own `fontSizeOverride ??
+ * fitFontSize(text, width*0.9, height, 12)` fallback, a crude, un-derived
+ * `0.6` char-width heuristic capped at a literal 12px (9pt) regardless of
+ * the diagram's real declared `primFontSz`. Measured against the full
+ * gallery: dozens of `hierarchy`/`organization-chart`/`pyramid`-family
+ * fixtures rendered a flat ~8-9pt for cached sizes of 20-70pt. This wires
+ * the SAME shared fitter `lin`/`snake`/`cycle` already use, with an
+ * explicit `fontRoleNode` (the first resolved slot's own layoutNode) since
+ * `itemFontBoundsPx`'s `itemNode(plan.node)` first-child heuristic does not
+ * apply to a composite's own slot structure (see `smartart-layout-item-
+ * font-tier.ts`'s `fontRoleNode` parameter doc).
+ */
+import type { DiagramLayoutNode } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { ChooseAwareSlot } from './smartart-layout-interpreter-composite-group-slots.js';
+import type { SelfDesPair } from './smartart-layout-interpreter-composite-pairs.js';
+import type { ArrangementPlan } from './smartart-layout-interpreter-model.js';
+/** What a shared font-fit computation needs from the caller; see `resolveSharedFontFit`. */
+export interface FontFitContext {
+    plan: ArrangementPlan;
+    index: ConstraintIndex;
+    fontName: string | undefined;
+}
+/** A resolved shared font size (root + folded-descendant). */
+export interface SharedFontFit {
+    rootSizePx: number;
+    descendantSizePx: number;
+}
+/** One item's own text (plus any folded descendant texts) and box, for {@link resolveSharedFontFit}. */
+export interface FontFitCandidate {
+    rootText: string;
+    descendantTexts: readonly string[];
+    width: number;
+    height: number;
+}
+/** Resolve ONE shared font size across `items`, or `undefined` when there are none to fit. */
+export declare function resolveSharedFontFit(fontCtx: FontFitContext, fontRoleNode: DiagramLayoutNode | undefined, items: FontFitCandidate[]): SharedFontFit | undefined;
+/** {@link resolveSharedFontFit}, building `FontFitCandidate`s directly from `collectSelfDesPairs`' output. */
+export declare function resolveFontFitFromPairs(fontCtx: FontFitContext | undefined, fontRoleNode: DiagramLayoutNode | undefined, pairs: SelfDesPair[]): SharedFontFit | undefined;
+/**
+ * One shared font-fit per distinct `declaringRole` among `slots` - see
+ * `arrangeByChooseAwareSlots`'s own doc comment (`smartart-layout-
+ * interpreter-composite-choose.ts`) for why a single global fit
+ * over-restricts a choose-aware composite whose slots come from more than
+ * one named wrapper group (`cycle-matrix`/`grid-matrix`/`segmented-
+ * pyramid`'s shape - each named group carries its own, genuinely different,
+ * declared `primFontSz` ceiling, unlike `upward-arrow`'s own count-branches,
+ * which all share ONE wrapper and so degenerate to a single shared fit
+ * here regardless).
+ */
+export declare function resolveFitByDeclaringRole(fontCtx: FontFitContext, slots: ChooseAwareSlot[]): Map<string, SharedFontFit | undefined>;
+//# sourceMappingURL=smartart-layout-interpreter-composite-fontfit.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-composite-fontfit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-fontfit.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-fontfit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qDAAqD,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAG3E,4FAA4F;AAC5F,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,eAAe,CAAC;IACvB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAED,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CACzB;AAED,wGAAwG;AACxG,MAAM,WAAW,gBAAgB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,8FAA8F;AAC9F,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,iBAAiB,GAAG,SAAS,EAC3C,KAAK,EAAE,gBAAgB,EAAE,GACvB,aAAa,GAAG,SAAS,CAa3B;AAED,8GAA8G;AAC9G,wBAAgB,uBAAuB,CACtC,OAAO,EAAE,cAAc,GAAG,SAAS,EACnC,YAAY,EAAE,iBAAiB,GAAG,SAAS,EAC3C,KAAK,EAAE,WAAW,EAAE,GAClB,aAAa,GAAG,SAAS,CAc3B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACxC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,eAAe,EAAE,GACtB,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS,CAAC,CAyBxC"}

package/dist/diagram/layout/smartart-layout-interpreter-composite-foreach.d.ts

@@ -0,0 +1,36 @@
+/**
+ * SmartArt DiagramML interpreter - compound-`forEachOrigin`-bound composite
+ * slot resolution.
+ *
+ * `hexagon-radial--hier5.pptx`'s `Child1`..`Child6`: each is a `self`-family
+ * (`presOf axis="desOrSelf"`) slot, individually positioned via the
+ * composite's own `for="ch" forName="ChildN"` constraints, but reached
+ * through its OWN COMPOUND `dgm:forEach axis="ch ch" ptType="node node"
+ * st="1 N" cnt="1 1"` - "top-level point 1's Nth child", independent of any
+ * other slot's own binding (unlike `arrangeByPresentationOf`'s ordinal
+ * `selfSlots[i] <-> nodes[i]` matching, which assumes a SHARED sequential
+ * point stream). Resolved the exact same way a `dgm:choose` guard's compound
+ * `@axis` is (`smartart-layout-interpreter-axis-count.ts`'s
+ * `resolveAxisNodes`), applied to the slot's OWN `forEachOrigin` instead of a
+ * `dgm:if`'s condition. Pure geometry; no framework code.
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { SlotStyleContext } from './smartart-layout-interpreter-composite.js';
+import type { SlottedDims } from './smartart-layout-interpreter-composite-slots.js';
+import type { BoundingBox, RenderedNode } from './smartart-layout-types.js';
+/**
+ * `slotted` entries whose own `presOf` is a SINGLE token (`self`/`des`/
+ * `desOrSelf`) but reached through a COMPOUND `forEachOrigin` (2+ hops,
+ * first hop `ch`) - the shape {@link resolveForEachBoundContent} resolves.
+ * Excludes anything `arrangeByPresentationOf`'s ordinal `self`/`des` matching
+ * already handles (a compound forEachOrigin never appears on a plain,
+ * document-order-matched slot in any fixture measured).
+ */
+export declare function forEachBoundSlots(slotted: SlottedDims[]): SlottedDims[];
+/**
+ * Render every `forEachBoundSlots` entry as its own box (see this module's
+ * doc comment) - one box per slot, each independently anchored, `index`
+ * continuing from the caller's own ordinal-matched count so keys stay unique.
+ */
+export declare function renderForEachBoundSlots(slots: SlottedDims[], flat: DiagramNode[], box: BoundingBox, absX: number, absY: number, childrenOf: Map<string, DiagramNode[]>, ctx: SlotStyleContext, startIndex: number): RenderedNode[];
+//# sourceMappingURL=smartart-layout-interpreter-composite-foreach.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-composite-foreach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-foreach.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-foreach.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAqB,WAAW,EAAE,MAAM,UAAU,CAAC;AAE/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAEhF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEjF,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAoB,MAAM,yBAAyB,CAAC;AAG3F;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAMvE;AAqCD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,WAAW,EAAE,EACpB,IAAI,EAAE,WAAW,EAAE,EACnB,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,GAAG,EAAE,gBAAgB,EACrB,UAAU,EAAE,MAAM,GAChB,YAAY,EAAE,CA6BhB"}