ooxml-core 1.1.0 → 1.2.0

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

@@ -0,0 +1,60 @@
+/**
+ * SmartArt DiagramML interpreter - `dgm:choose`-wrapped `dgm:alg` resolution.
+ *
+ * Split out of `smartart-layout-interpreter-flow.ts` to keep that file under
+ * the repo's per-file line budget: this half resolves a decidable `dgm:choose`
+ * to its winning branch's arrangement algorithm - the TYPE alone
+ * ({@link chooseAlgType}, the pre-existing entry point) or the type PLUS every
+ * `dgm:param` it declares ({@link chooseAlgorithm}).
+ *
+ * The full-algorithm resolution matters because the typed layout model only
+ * parses a DIRECT `dgm:alg` child of a layoutNode into that node's own
+ * `algorithm` field; a `dgm:alg` living entirely inside a `dgm:choose`
+ * (mirroring `dir="rtl"`, the common real-world shape) leaves that field
+ * `undefined` at parse time. `discoverArrangement`
+ * (`smartart-layout-interpreter-model.ts`) uses {@link chooseAlgorithm} to
+ * populate the chosen arranger node's `algorithm` with the WINNING branch's
+ * real params, not just its type, when it falls back to the choose-wrapped
+ * node itself.
+ *
+ * Every entry point takes a {@link RawXmlView} that turns the model's raw
+ * branch slot into the ordered-XML element the walk reads (see
+ * `smartart-choose-xml.ts`).
+ */
+import type { DiagramLayoutAlgorithm, DiagramLayoutNode } from '../model/index.js';
+import type { RawXmlView } from './smartart-choose-xml.js';
+import type { WhenContext } from './smartart-layout-interpreter-when.js';
+/**
+ * Resolve a decidable `dgm:choose` on `node` to the structural algorithm type
+ * it selects, or `undefined` when no choose is decidable (in which case the
+ * caller keeps the blind first-recognised-alg behaviour). Decidable on
+ * `func="cnt"` from `nodeCount` alone, or on `func="var"` when `context`
+ * carries `presLayoutVars`; `pos`/`revPos`/`posEven`/`posOdd`/`depth`/
+ * `maxDepth` are decidable too when `context` supplies the declaring layout
+ * node's own tree location. `context` defaults to `{}` (those functions stay
+ * undecidable then).
+ */
+export declare function chooseAlgType<R>(view: RawXmlView<R>, node: DiagramLayoutNode<R>, nodeCount: number, context?: WhenContext): string | undefined;
+/**
+ * Same decidability rules as {@link chooseAlgType}, but resolves the winning
+ * branch's FULL algorithm (type plus every `dgm:param`), not just its type -
+ * see {@link branchAlg}'s doc comment for why a type-only resolution loses a
+ * choose-wrapped arranger's own params entirely. A `composite` found by
+ * `boundedCompositeAlg` is the fallback, tried only once every branch's own
+ * structural search has found nothing.
+ */
+export declare function chooseAlgorithm<R>(view: RawXmlView<R>, node: DiagramLayoutNode<R>, nodeCount: number, context?: WhenContext): DiagramLayoutAlgorithm | undefined;
+/**
+ * Resolve a decidable `dgm:choose` to a WINNING branch algorithm whose type
+ * belongs to `allowedTypes` - a generalisation of {@link chooseAlgType}/
+ * {@link chooseAlgorithm} for a caller that needs a type OUTSIDE their own
+ * `CHOOSE_ALG_TYPES` whitelist (e.g. `tx`, for hierarchy generation-template
+ * detection - `smartart-hierarchy-generation-templates.ts`).
+ *
+ * Deliberately kept SEPARATE rather than widening `CHOOSE_ALG_TYPES` itself:
+ * that whitelist also gates `discoverArrangement`'s own ARRANGEMENT dispatch,
+ * and widening it there for an unrelated type has previously regressed
+ * unrelated fixtures. No `composite` fallback here.
+ */
+export declare function chooseAlgorithmOfType<R>(view: RawXmlView<R>, node: DiagramLayoutNode<R>, nodeCount: number, allowedTypes: ReadonlySet<string>, context?: WhenContext): DiagramLayoutAlgorithm | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-choose-algorithm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-choose-algorithm.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-choose-algorithm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAI3E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAkGtE;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC9B,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC1B,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,WAAgB,GACvB,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAChC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC1B,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,WAAgB,GACvB,sBAAsB,GAAG,SAAS,CAqBpC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACtC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC1B,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,EACjC,OAAO,GAAE,WAAgB,GACvB,sBAAsB,GAAG,SAAS,CAgBpC"}

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

@@ -0,0 +1,36 @@
+/**
+ * SmartArt DiagramML interpreter - `dgm:choose` branch selection (top-level
+ * and nested).
+ *
+ * Split out of `smartart-layout-interpreter-choose-algorithm.ts` (the
+ * file-size budget): the two functions that pick WHICH branch is active, for
+ * a layoutNode's own parsed `dgm:choose` ({@link activeBranch}, returning the
+ * branch's raw-XML slot as the model holds it) and for one living entirely
+ * inside an already-active branch's body ({@link nestedChooseBranch}, over
+ * the ordered-XML tree) - see that module's own doc comment for how
+ * `branchAlg` uses both.
+ */
+import type { DiagramChoose } from '../model/index.js';
+import type { OrderedXmlElement } from './smartart-choose-xml.js';
+import type { WhenContext } from './smartart-layout-interpreter-when.js';
+/**
+ * Resolve the raw XML of the active `dgm:choose` branch for a node count, or
+ * `undefined` when the choose is not decidable (an earlier branch is
+ * undecidable) or no branch applies. DiagramML picks the first matching `if` in
+ * order, so an undecidable earlier branch forces a bail.
+ */
+export declare function activeBranch<R>(choose: DiagramChoose<R>, nodeCount: number, context: WhenContext): R | undefined;
+/**
+ * Resolve a NESTED `dgm:choose` (one living entirely inside an already-active
+ * branch's raw XML, e.g. `basic-radial--hier5.pptx`'s `stAng` choose nested
+ * inside its `dir="norm"` branch) to its own winning branch, or `undefined`
+ * when it is not decidable - never a raw `dgm:if`/`dgm:else` `branchAlg`'s
+ * blind walk would otherwise recurse into UNCONDITIONALLY. Only a
+ * layoutNode's OWN direct `dgm:choose` children are parsed into the typed
+ * model at load time; one nested inside a branch is only ever reachable
+ * here, parsed on the fly with the SAME `dgm:if` attribute parser the
+ * top-level reader uses, so it decides with the exact same rules (including
+ * compound `@axis` navigation - see `smartart-layout-interpreter-when.ts`).
+ */
+export declare function nestedChooseBranch(choose: OrderedXmlElement, nodeCount: number, context: WhenContext): OrderedXmlElement | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-choose-branch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-choose-branch.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-choose-branch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAI/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAEtE;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC7B,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,WAAW,GAClB,CAAC,GAAG,SAAS,CAWf;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,iBAAiB,EACzB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,WAAW,GAClB,iBAAiB,GAAG,SAAS,CAsB/B"}

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

@@ -0,0 +1,42 @@
+/**
+ * SmartArt DiagramML interpreter - bounded `dgm:choose`-wrapped `composite`
+ * fallback.
+ *
+ * Split out of `smartart-layout-interpreter-choose-algorithm.ts` (the
+ * file-size budget): {@link boundedCompositeAlg} is a SEPARATE, narrower
+ * search from that module's own `branchAlg`, used ONLY as a fallback after
+ * `branchAlg` finds nothing at all for the same branch - see its own doc
+ * comment for the full reasoning (the previously-measured regressions a
+ * blind, unbounded `composite` search caused, and why this one avoids them).
+ */
+import type { OrderedXmlElement } from './smartart-choose-xml.js';
+import type { WhenContext } from './smartart-layout-interpreter-when.js';
+/** A recognised `dgm:alg` found inside a branch's XML, its type plus the raw element (for its `dgm:param`s). */
+export interface FoundBranchAlg {
+    type: string;
+    raw: OrderedXmlElement;
+}
+/**
+ * First `dgm:alg type="composite"` declared inside a branch's XML, WITHOUT
+ * ever crossing into a nested `dgm:layoutNode` - a SEPARATE, narrower search
+ * from `smartart-layout-interpreter-choose-algorithm.ts`'s `branchAlg` (see
+ * `CHOOSE_ALG_TYPES`'s own doc comment there for the measured regressions a
+ * blind, unbounded `composite` search caused: it matched an UNRELATED nested
+ * composite reached through a child layoutNode - a per-item template, or a
+ * sibling arranger's own choose - stealing the decision from a genuinely
+ * earlier `cycle`/`lin` alg before it was ever reached; bounding the WHOLE
+ * walk at a layoutNode boundary regressed STRUCTURAL resolution elsewhere
+ * instead, which legitimately does need to cross into a child layoutNode).
+ * This function is used ONLY as a fallback (see `chooseAlgType`/
+ * `chooseAlgorithm`), tried AFTER `branchAlg` finds nothing at all for the
+ * SAME branch - it can never out-rank an already-reachable structural type,
+ * and its own search never crosses a `dgm:layoutNode` boundary, so it cannot
+ * reach an unrelated nested composite the way the reverted whole-type-set
+ * addition did. `hexagon-radial--hier5.pptx`'s `Name0` needs exactly this
+ * shape: an outer `dgm:if func="var" arg="dir"` wraps an INNER `dgm:choose`
+ * with per-child-count `dgm:if`s, each selecting a DIFFERENT `dgm:alg
+ * type="composite"` - two choose levels deep, no intervening layoutNode at
+ * all.
+ */
+export declare function boundedCompositeAlg(raw: OrderedXmlElement | undefined, nodeCount: number, context: WhenContext): FoundBranchAlg | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-choose-composite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-choose-composite.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-choose-composite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAEtE,gHAAgH;AAChH,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,iBAAiB,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CAClC,GAAG,EAAE,iBAAiB,GAAG,SAAS,EAClC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,WAAW,GAClB,cAAc,GAAG,SAAS,CAgC5B"}

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

@@ -0,0 +1,102 @@
+/**
+ * SmartArt DiagramML interpreter - `dgm:choose`-resolved structural
+ * algorithm depth.
+ *
+ * `discoverArrangement`'s choose-branch (`smartart-layout-interpreter-
+ * model.ts`) lets a decidable `dgm:choose` pick the diagram's WHOLE
+ * structural algorithm, ranked above a genuine top-level `composite`
+ * arranger by design (`cycle-matrix--fallback-n2.pptx`'s own `dgm:choose`
+ * genuinely decides between `composite`/other alternatives for the WHOLE
+ * diagram). That precedence is wrong when the choose-decided algorithm was
+ * found by tunnelling several `dgm:layoutNode` levels DOWN INTO one of the
+ * composite's own child slots, rather than at the winning branch's own
+ * top level - `nested-target--hier5.pptx`'s `Name0` carries a direct
+ * `dgm:alg type="composite"` AND a separate content-flattening `.choose`
+ * (deciding which concentric target ring is live); that choose's winning
+ * branch's raw XML nests `outerBox` -> `outerBoxChildren` -> a genuinely
+ * choose-wrapped `dgm:alg type="lin"` TWO `dgm:layoutNode` levels down (a
+ * small per-slot item arrangement for the 3 boxes inside ONE of `Name0`'s
+ * own slots, not a competing whole-diagram algorithm).
+ *
+ * {@link structuralChooseAlgDepth} measures this: how many `dgm:layoutNode`
+ * boundaries the winning branch's raw XML crosses before the FIRST
+ * structural (`lin`/`cycle`/`pyra`/`snake`/`hierChild`/`hierRoot`) `dgm:alg`
+ * is found, or `undefined` when none is found at all. Corpus-measured
+ * (`bunx tsx` a one-off scratchpad script over the whole 227-fixture
+ * gallery, every fixture whose root carries both a direct `composite` alg
+ * and its own `.choose`) against every fixture where the resolved
+ * structural type is `lin`: `accented-picture`, `horizontal-picture-list`,
+ * `pyramid-list` (x3 datasets) all resolve at depth 1 and are all ALREADY
+ * correctly `'linear'` (unaffected by any change here); `nested-target` is
+ * the ONLY one at depth 2, and is the ONLY one that is WRONG (should be
+ * `'composite'`) - a clean, monotonic separator across the measured corpus.
+ * `discoverArrangement` uses `depth >= 2` (paired with the SAME "does this
+ * node ALSO independently qualify as its own genuine composite" check
+ * `compositeSlot`'s own assignment uses) to decide when to let the node's
+ * own composite identity win instead of the tunnelled choose result.
+ *
+ * Deliberately a SEPARATE, standalone walk from `smartart-layout-
+ * interpreter-choose-algorithm.ts`'s own `branchAlg` (not exported, and
+ * that file explicitly documents TWO prior attempts to change its search
+ * scope that each regressed a different fixture set - not a function to
+ * extend casually) rather than an extension of it - this only ever reads
+ * `DiagramLayoutNode.choose` via the already-exported `activeBranch`/
+ * `nestedChooseBranch`/`localName` (`smartart-layout-interpreter-choose-
+ * branch.ts`), so it needs no change to that file or to `branchAlg` at all.
+ * Restricted to STRUCTURAL types only (never `composite`), mirroring
+ * `branchAlg`'s own `CHOOSE_ALG_TYPES` set (duplicated here rather than
+ * imported, since it is not exported).
+ *
+ * {@link tunnelsPastOwnCompositeSlot} is the single combined check
+ * `discoverArrangement` actually calls. Blocking only `Name0`'s OWN attempt
+ * was measured NOT sufficient on its own: `discoverArrangement`'s walk
+ * visits every flattened choose-alternative unconditionally (chooseGuard
+ * "is this branch live" filtering happens elsewhere, never during this
+ * walk), so `nested-target`'s `middleBox`/`centerBox` - each flattened
+ * onto `Name0.children` the exact same way `outerBox` is, each with its OWN
+ * separate, SHALLOW-resolving nested `.choose` for its own 3-box `lin`
+ * direction - would otherwise be visited next and independently re-assert
+ * the identical wrong whole-diagram pick. `discoverArrangement` handles
+ * this by excluding `node`'s WHOLE subtree (not just the specific crossed
+ * path) once `tunnelsPastOwnCompositeSlot` returns `true` for it - see its
+ * own `blockedSubtreeRoots` + `isLayoutNodeOrDescendantOf`
+ * (`smartart-layout-interpreter-composite-detect.ts`).
+ *
+ * Pure TypeScript - no framework code, no DOM.
+ */
+import type { DiagramLayoutNode } from '../model/index.js';
+import type { RawXmlView } from './smartart-choose-xml.js';
+import type { WhenContext } from './smartart-layout-interpreter-when.js';
+/** A found structural `dgm:alg`, plus the ordered `name`s of every `dgm:layoutNode` crossed to reach it (outermost first) - see {@link structuralChooseAlgDepth}. */
+export interface StructuralChooseAlgResult {
+    depth: number;
+    /** `name` of each `dgm:layoutNode` crossed on the way to the found alg, outermost first (`['outerBox', 'outerBoxChildren']` for `nested-target`'s own tunnelled `lin`) - empty when `depth` is 0 (found at the winning branch's own top level, no crossing at all). */
+    crossedNames: string[];
+}
+/**
+ * `node`'s own `.choose` (its parsed top-level `dgm:choose` list), resolved
+ * to the `dgm:layoutNode`-crossing depth at which the first STRUCTURAL
+ * (`lin`/`cycle`/`pyra`/`snake`/`hierChild`/`hierRoot`) algorithm is found
+ * in the winning branch, plus the ordered `name`s of every `dgm:layoutNode`
+ * crossed to reach it (kept for diagnostics/tests; `discoverArrangement`
+ * itself keys its own exclusion off `node` as a whole - see
+ * {@link tunnelsPastOwnCompositeSlot}) - or `undefined` when `node` has no
+ * choose, no branch is decidable, or none resolves to a structural type at
+ * all. See this module's own doc comment for the full derivation and the
+ * corpus measurement behind the `depth >= 2` threshold.
+ */
+export declare function structuralChooseAlgDepth<R>(view: RawXmlView<R>, node: DiagramLayoutNode<R>, nodeCount: number, context: WhenContext): StructuralChooseAlgResult | undefined;
+/**
+ * `true` when `node` ALSO independently qualifies as its own genuine
+ * top-level composite (the SAME three conditions `discoverArrangement`'s
+ * own `compositeSlot` assignment checks: a direct, non-choose-wrapped
+ * `composite` algorithm, not a per-item template, no DIRECT structural
+ * descendant of its own, and real mapped slots) AND its `.choose` resolves
+ * a structural type by tunnelling 2+ `dgm:layoutNode` levels down - see
+ * this module's own doc comment for the corpus-measured, monotonic
+ * threshold. `discoverArrangement` uses this single combined check to
+ * decide when to let `node`'s own composite identity win instead of a
+ * choose result that only ever described one of its own child slots.
+ */
+export declare function tunnelsPastOwnCompositeSlot<R>(view: RawXmlView<R>, node: DiagramLayoutNode<R>, nodeCount: number, context: WhenContext, itemTemplates: ReadonlySet<DiagramLayoutNode<R>>): boolean;
+//# sourceMappingURL=smartart-layout-interpreter-choose-depth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-choose-depth.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-choose-depth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAI3E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAYtE,qKAAqK;AACrK,MAAM,WAAW,yBAAyB;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,uQAAuQ;IACvQ,YAAY,EAAE,MAAM,EAAE,CAAC;CACvB;AA6CD;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EACzC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC1B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,WAAW,GAClB,yBAAyB,GAAG,SAAS,CAevC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAC5C,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC1B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,WAAW,EACpB,aAAa,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAC9C,OAAO,CAWT"}

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

@@ -0,0 +1,32 @@
+/**
+ * SmartArt DiagramML interpreter - non-hierarchy `dgm:choose` branch
+ * classification for `discoverArrangement`.
+ *
+ * Split out of `smartart-layout-interpreter-model.ts` (the repo's per-file
+ * line budget): given a `dgm:choose`-bearing `node` whose winning branch's
+ * algorithm has already been resolved (`chooseAlgorithm`, NOT a `hierRoot`/
+ * `hierChild` - that case stays in `discoverArrangement` itself, since it
+ * compares nodes by reference against the original tree), decides whether
+ * that branch should win `chosen`, or is disqualified - a slot's own tiny
+ * internal arrangement, a pos-guarded per-position template, a tunnelled
+ * result, or an already-resolved composite's own named alternative slot.
+ * Pure TypeScript - no framework code, no DOM.
+ */
+import type { DiagramLayoutAlgorithm, DiagramLayoutNode, DiagramNode } from '../model/index.js';
+import type { RawXmlView } from './smartart-choose-xml.js';
+import type { ArrangementPlan } from './smartart-layout-interpreter-arrangement-kind.js';
+import type { WhenContext } from './smartart-layout-interpreter-when.js';
+export interface ChooseResolution<R = unknown> {
+    chosen: ArrangementPlan<R> | undefined;
+    /** `true` when `node` should be added to `blockedSubtreeRoots` (a tunnelled result). */
+    blockSubtree: boolean;
+}
+/**
+ * Classify a `dgm:choose`-resolved non-hierarchy branch - see this module's
+ * own doc comment for the precedence this implements (mirrors
+ * `discoverArrangement`'s own precedence list, items 2-3).
+ */
+export declare function resolveNonHierarchyChoose<R>(view: RawXmlView<R>, node: DiagramLayoutNode<R>, resolvedAlg: DiagramLayoutAlgorithm | undefined, nodeCount: number, whenContext: WhenContext & {
+    nodes?: DiagramNode[] | undefined;
+}, itemTemplates: ReadonlySet<DiagramLayoutNode<R>>, compositeSlot: DiagramLayoutNode<R> | undefined): ChooseResolution<R>;
+//# sourceMappingURL=smartart-layout-interpreter-choose-resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-choose-resolve.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-choose-resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAC;AActF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAEtE,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,OAAO;IAC5C,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACvC,wFAAwF;IACxF,YAAY,EAAE,OAAO,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAC1C,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC1B,WAAW,EAAE,sBAAsB,GAAG,SAAS,EAC/C,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,WAAW,GAAG;IAAE,KAAK,CAAC,EAAE,WAAW,EAAE,GAAG,SAAS,CAAA;CAAE,EAChE,aAAa,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAChD,aAAa,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,SAAS,GAC7C,gBAAgB,CAAC,CAAC,CAAC,CAqErB"}

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

@@ -0,0 +1,33 @@
+/**
+ * SmartArt DiagramML interpreter - composite slot alternative detection.
+ *
+ * `discoverArrangement`'s own top-level walk (`smartart-layout-interpreter-
+ * model.ts`) can reach a `dgm:choose`-flattened branch that describes ONE of
+ * an already-resolved top-level `composite`'s OWN slots, not a competing
+ * whole-diagram algorithm - `radial-cluster--hier5.pptx`'s `singleCycle`, a
+ * `cycle` alg reached through `Name0`'s own `<dgm:forEach name="singleCycle"
+ * ...>`. Pure TypeScript - no framework code, no DOM.
+ */
+import type { DiagramLayoutNode } from '../model/index.js';
+/**
+ * `true` when `node` was reached through one of `compositeSlot`'s OWN
+ * `dgm:forEach` children (matched by `@name`, the one stable identity a
+ * choose-flattened forEach-wrapped alternative still carries after
+ * `nestedLayoutNodes` flattens both the `dgm:forEach` and any `dgm:choose`
+ * wrapping it onto `.children`) - i.e. `node` IS one of `compositeSlot`'s
+ * own child slots, reached via a different branch of the same `dgm:choose`
+ * machinery that `compositeSlot` itself already resolved through
+ * `mapsSlots`. A structural algorithm resolved from such a node describes
+ * that ONE SLOT's own small internal arrangement, not a competing
+ * whole-diagram algorithm - `compositeSlot`'s own top-level composite
+ * identity must win instead.
+ *
+ * `false` whenever `compositeSlot` is not yet resolved (nothing to compare
+ * against - by construction the composite root is always visited before any
+ * descendant reached through one of its own forEach-wrapped slots, in the
+ * same preorder walk, so this never fires prematurely), or `node` carries no
+ * `forEachOrigin` of its own (a direct child, never reached through ANY
+ * forEach).
+ */
+export declare function isMappedSlotAlternative(compositeSlot: DiagramLayoutNode | undefined, node: DiagramLayoutNode): boolean;
+//# sourceMappingURL=smartart-layout-interpreter-composite-alternative.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-alternative.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-alternative.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CACtC,aAAa,EAAE,iBAAiB,GAAG,SAAS,EAC5C,IAAI,EAAE,iBAAiB,GACrB,OAAO,CAMT"}

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

@@ -0,0 +1,95 @@
+/**
+ * SmartArt DiagramML interpreter - `forEachOrigin`-anchored `presOf`
+ * content resolution.
+ *
+ * A `presOf`-bearing layoutNode's own axis (`self`/`des`/`desOrSelf`/a
+ * compound chain) is resolved relative to the DIAGRAM ROOT by default (every
+ * `dgm:if`-level guard, and a composite's own root-relative slots -
+ * `smartart-layout-interpreter-composite-choose.ts`'s `cycle-matrix`/
+ * `balance` shape). That default is wrong for a node reached through a
+ * `dgm:forEach` (its own {@link DiagramLayoutNode.forEachOrigin}):
+ * such a node's content is scoped to THAT forEach's own resolved point(s),
+ * not the whole diagram - `Phased Process`'s `circ1Tx` (`presOf
+ * axis="desOrSelf"`) sits inside a `dgm:forEach axis="ch ch" ptType="node
+ * node" st="2 1" cnt="1 1"` ("point 2's first child"), so its `desOrSelf`
+ * must fold in THAT point's own descendants, not the entire diagram's.
+ * {@link resolveAnchoredContent} is the ONE place this anchor/root split is
+ * decided, shared by every composite content-resolution path so it is fixed
+ * once, not per caller (`smartart-layout-interpreter-composite-choose.ts`'s
+ * root-relative collection and `smartart-layout-interpreter-composite-
+ * foreach.ts`'s compound-forEachOrigin slots both consume it).
+ *
+ * {@link resolveAnchoredContentPerAnchor} is the SAME anchor resolution, but
+ * kept as one content array PER anchor instead of folded into one - the
+ * genuine "one item template, N `dgm:forEach` iterations" reading ECMA-376
+ * 21.4.2.13 describes for a forEach with an UNBOUNDED second hop (`axis="ch
+ * ch" st="1 1" cnt="1 0"`, "every child of point 1", `nested-target--
+ * hier5.pptx`'s `oChild`) - as opposed to a forEach that always resolves to
+ * exactly ONE anchor (`Phased Process`'s per-phase slots, `st="N M" cnt="1
+ * 1"`), where the two readings coincide. See
+ * `smartart-layout-interpreter-composite-choose.ts` for how a multi-anchor
+ * result becomes one rendered box per anchor instead of one box with every
+ * anchor's text folded together.
+ *
+ * Pure geometry; no framework code.
+ */
+import type { DiagramLayoutNode, DiagramNode, DiagramIteratorAttributes } from '../model/index.js';
+/**
+ * Resolve `node`'s own `presOf` axis, anchored by its `forEachOrigin` when
+ * present (`node`'s `presOf` axis navigates from the origin's own resolved
+ * anchor set instead of the root), falling back to plain root-relative
+ * resolution for a node with no enclosing forEach (`cycle-matrix`'s
+ * `child1Text`, `quadrant1..4`: bare `chooseGuard`-gated content, never
+ * forEach-wrapped). Returns `[]` when `presOf` is absent, its axis is empty,
+ * or the anchor itself resolves to nothing (the forEach's own axis matched
+ * no point, e.g. a phase slot whose count guard excludes it). When the
+ * forEach resolves to MULTIPLE anchors, every anchor's content is folded
+ * into this ONE array - see {@link resolveAnchoredContentPerAnchor} for the
+ * per-anchor reading a genuine multi-iteration forEach needs instead.
+ */
+export declare function resolveAnchoredContent(node: DiagramLayoutNode, flat: DiagramNode[]): DiagramNode[];
+/**
+ * Like {@link resolveAnchoredContent}, but returns ONE content array PER
+ * anchor instead of folding every anchor's content into one - see this
+ * module's own doc comment for the ECMA-376 reading this implements. For a
+ * node with no `forEachOrigin`, or one that resolves to a single anchor,
+ * this returns exactly the same single-element (or empty) result
+ * `resolveAnchoredContent` itself would, wrapped in an outer array - a
+ * strict generalisation, not a separate mechanism. Drops any anchor whose
+ * own content resolves empty (a `presOf` axis that matched nothing for that
+ * particular anchor).
+ */
+export declare function resolveAnchoredContentPerAnchor(node: DiagramLayoutNode, flat: DiagramNode[]): DiagramNode[][];
+/** One anchor's resolved content, plus its position among EVERY anchor (not
+ * just the non-empty ones) - see {@link resolveAnchoredContentPerAnchorFrom}. */
+export interface AnchoredContentGroup {
+    content: DiagramNode[];
+    /** 0-based position of this group's anchor among every anchor `origin` resolved (not just the non-empty ones). */
+    anchorIndex: number;
+    /** Total anchor count `origin` resolved (including empty ones) - the divisor a sibling role's OWN per-anchor slicing must stay aligned to. */
+    anchorCount: number;
+}
+/**
+ * Like {@link resolveAnchoredContentPerAnchor}, but for a `presOf`-bearing
+ * `node` that has NO `forEachOrigin` of its OWN - `origin` is supplied by an
+ * ANCESTOR bare (non-`presOf`) layoutNode's own `forEachOrigin` instead
+ * (`continuous-arrow-process--hier5.pptx`'s `parTx`/`desTx`: both sit two
+ * `dgm:layoutNode` levels inside `linV`, the actual per-point item template
+ * that carries the real `axis="ch" ptType="node"` origin - see
+ * `smartart-layout-interpreter-composite-choose.ts`'s `collectRawCandidates`,
+ * the one caller that threads an ancestor's origin down this way).
+ *
+ * Keeps EVERY anchor's `anchorIndex`/`anchorCount` aligned to the FULL
+ * anchor list, dropping only the individual groups whose own content
+ * resolves empty (`Node Three` has no child, so `desTx`'s own per-anchor
+ * resolution for it is empty) - unlike {@link resolveAnchoredContentPerAnchor},
+ * which renumbers around the gaps. Renumbering would misalign a `des`-axis
+ * sibling role (`desTx`, 2 non-empty anchors) against a `self`-axis one
+ * (`parTx`, 3 non-empty anchors) that shares the SAME anchor list: both need
+ * `resolveIterationRect` (`smartart-layout-interpreter-composite-
+ * iteration.ts`) to slice the SAME shared container into the SAME 3 columns,
+ * so `Node Four`'s own `desTx` must stay at `anchorIndex=2` of `3`, not
+ * shift to `1` of `2` just because `Node Three`'s own group was empty.
+ */
+export declare function resolveAnchoredContentPerAnchorFrom(node: DiagramLayoutNode, flat: DiagramNode[], origin: DiagramIteratorAttributes): AnchoredContentGroup[];
+//# sourceMappingURL=smartart-layout-interpreter-composite-anchor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-anchor.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-anchor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAa1F;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,WAAW,EAAE,GACjB,WAAW,EAAE,CAgBf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,+BAA+B,CAC9C,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,WAAW,EAAE,GACjB,WAAW,EAAE,EAAE,CAqBjB;AAED;iFACiF;AACjF,MAAM,WAAW,oBAAoB;IACpC,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,kHAAkH;IAClH,WAAW,EAAE,MAAM,CAAC;IACpB,8IAA8I;IAC9I,WAAW,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mCAAmC,CAClD,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,WAAW,EAAE,EACnB,MAAM,EAAE,yBAAyB,GAC/B,oBAAoB,EAAE,CAmBxB"}

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

@@ -0,0 +1,84 @@
+/**
+ * SmartArt DiagramML interpreter - composite `dgm:alg/@ar` (aspect ratio)
+ * handling, scoped to a `userS`-declared hub role.
+ *
+ * A `composite` algorithm's own `<dgm:param type="ar" val="...">` (ECMA-376
+ * CT_AlgorithmData, "aspect ratio") establishes an internal working
+ * rectangle a `userS`-anchored hub slot's own `w`/`h` size fact is a
+ * fraction of, DISTINCT from the raw allocated box: PowerPoint fits a
+ * rectangle of that aspect ratio inside the allocated box (the limiting
+ * dimension keeps its full extent, the other shrinks to match), then reads
+ * the hub's `w`/`h` `dgm:constr` `fact` against THAT working rectangle's own
+ * width/height, not the outer box's.
+ *
+ * COM-verified against `radial-cluster--hier5.pptx` (`Name0`'s own
+ * `<dgm:alg type="composite"><dgm:param type="ar" val="1.00"/></dgm:alg>`,
+ * diagram box `867x533`): `textCenter`'s own choose-selected `w` fact for
+ * this fixture's 3-satellite branch is `0.21`. Reading it against the raw
+ * box width (`0.21 * 867 = 182.07px`) misses the cached hub size (`112px`)
+ * by 62%; reading it against the `ar=1` working rectangle's own width
+ * (`min(867, 533) = 533`, since the box is wider than square: `0.21 * 533 =
+ * 111.93px`) matches the cached `112px` within 0.07px (0.06%) - far too
+ * precise to be coincidental for a COM-authored fixture.
+ *
+ * **Deliberately scoped to a `userS`-referenced role only**
+ * ({@link isUserSizeHubRole}), not every `w`/`h` in an `ar`-declaring
+ * composite: an unscoped version (every child slot's `w`/`h` read against
+ * the working rectangle) was implemented and full-corpus-measured first -
+ * it fixed `radial-cluster` the same way, but ALSO regressed 4 unrelated
+ * fixtures with no `userS` construct at all (`interconnected-rings--hier5
+ * .pptx` `0.0634 -> 0.1257`, nearly doubling; `ascending-picture-accent-
+ * process--hier5.pptx`, `descending-block-list--hier5.pptx`, `radial-
+ * picture-list--fallback-n4.pptx`, all smaller upticks) - root-caused to a
+ * pixel/ratio inconsistency: a SIBLING slot's `l`/`t` can cross-reference
+ * the resized role's own `r`/`b` (far edge) through `smartart-constraint-
+ * solver.ts`'s pure RATIO-space graph walk, which has no box to apply the
+ * `ar` adjustment to at all - only the DIRECT `dimOf` call for the resized
+ * role's own `w`/`h` did, so the two diverged. Gating on `userS` (a role
+ * other descendant nodes are ALREADY declared to size themselves relative
+ * to, `radial-cluster`'s own motivating construct) excludes every regressed
+ * fixture outright (none declares a `userS` constraint at all) while still
+ * reaching `radial-cluster`'s hub - verified via a full 229-fixture regen:
+ * 0 fixtures worse, `radial-cluster` alone better (`matched` intact at
+ * `5/5`, `maxDeltaFraction` `0.5535 -> 0.5141`).
+ *
+ * Position-type constraints (`l`/`t`/`ctrX`/`ctrY`) are deliberately NOT
+ * routed through this at all, hub role included: a centre-based position
+ * fact (`ctrX`/`ctrY`) happens to resolve identically whether read against
+ * the raw box or the (symmetrically centred) working rectangle, since the
+ * two share the same centre, but an edge-based one (`l`/`t`) would need the
+ * working rectangle's own inset accounted for as well - unverified, left
+ * out of scope. See `smartart-layout-interpreter-composite-slots.ts`'s
+ * `readSlots` for where this is wired in.
+ *
+ * Pure geometry; no framework code.
+ */
+import type { DiagramLayoutNode } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { BoundingBox } from './smartart-layout-types.js';
+/**
+ * The `ar` (aspect ratio, width/height) an algorithm's own `dgm:param`
+ * declares, or `undefined` when absent, non-numeric, or non-positive (every
+ * pre-existing composite with no `ar` param, the overwhelmingly common
+ * case, is unaffected).
+ */
+export declare function readAlgorithmAspectRatio(node: DiagramLayoutNode | undefined): number | undefined;
+/**
+ * Fit a rectangle of aspect ratio `ar` (width/height) inside `box`, keeping
+ * the limiting dimension at its full extent. Returns `box` itself (same
+ * values, cheap to compare) when `ar` is `undefined` or `box` already has
+ * that exact ratio - every caller with no `ar` to honour keeps its
+ * pre-existing box-relative sizing unchanged.
+ */
+export declare function fitAspectRatioBox(box: BoundingBox, ar: number | undefined): BoundingBox;
+/**
+ * True when some `dgm:constr type="userS"` anywhere in the layout declares
+ * `role` as its `refForName` target - i.e. another descendant node's own
+ * size is ALREADY declared (elsewhere) as a fraction of `role`'s own size
+ * (`radial-cluster`'s own `userS for="des" ptType="node" refType="w"
+ * refFor="ch" refForName="textCenter" fact="0.67"`). See this module's own
+ * doc comment for why the `ar`-fit working rectangle is scoped to exactly
+ * this role, not every `w`/`h` in an `ar`-declaring composite.
+ */
+export declare function isUserSizeHubRole(role: string, index: ConstraintIndex): boolean;
+//# sourceMappingURL=smartart-layout-interpreter-composite-aspect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-aspect.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-aspect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAOhG;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,CAgBvF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAS/E"}

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

@@ -0,0 +1,60 @@
+/**
+ * SmartArt DiagramML interpreter - raw choose-aware candidate collection.
+ *
+ * Split out of `smartart-layout-interpreter-composite-choose.ts` (the repo's
+ * per-file line budget): {@link collectRawCandidates} is the recursive walk
+ * that module's `collectChooseAwareSlots` wraps. Pure geometry; no framework
+ * code.
+ */
+import type { DiagramLayoutNode, DiagramNode, DiagramIteratorAttributes } from '../model/index.js';
+import type { RawSlotCandidate } from './smartart-layout-interpreter-composite-group-slots.js';
+/**
+ * Recursively walk `node`'s subtree collecting every choose-live,
+ * `presOf`-bearing, POSITIONED descendant as RAW candidates (content
+ * resolved, geometry not yet attempted) - see `collectChooseAwareSlots`
+ * (`smartart-layout-interpreter-composite-choose.ts`) for why this is a
+ * separate pass. A branch whose OWN `chooseGuard` evaluates false is dropped
+ * entirely, IT AND EVERYTHING NESTED INSIDE IT (`child2group`..`child4group`
+ * here, `fallback-n2` has only 1 top-level point). A bare wrapper (no
+ * `presOf` of its own - `children`, `child1group`, `circle`) is never itself
+ * a candidate; its children are resolved using ITS OWN role as the next
+ * `declaringRole`, since a nested composite re-scopes `for="ch"
+ * forName="X"` positioning to its own children (`child1group`'s own
+ * constrLst positions `child1`/`child1Text`, not `children`'s).
+ *
+ * A `presOf`-bearing node reached through a MULTI-anchor `forEachOrigin`
+ * (`nested-target--hier5.pptx`'s `oChild`: a genuine `dgm:forEach axis="ch
+ * ch" st="1 1" cnt="1 0"`, an UNBOUNDED second hop - "every child of point
+ * 1", not a fixed position) produces ONE candidate PER anchor
+ * (`resolveAnchoredContentPerAnchor`), not one candidate with every anchor's
+ * content folded together - the genuine "one item template, N forEach
+ * iterations" ECMA-376 21.4.2.13 describes, the same mechanism
+ * `sub-step-process--hier5.pptx`'s hand-duplicated `chLin1..7` templates
+ * need. Each anchor's OWN `guardAllows` check is deferred until its content
+ * is resolved (rather than checked once, up front, the way a bare wrapper's
+ * is) specifically so a `func="pos"`-family condition in `node`'s own
+ * `chooseGuard` chain can decide against THAT SPECIFIC iteration's own
+ * 1-based position - `sub-step-process`'s own `chLinN` templates each carry
+ * a `pos==N` guard this way (though `chLinN` itself is a STRUCTURAL
+ * arranger, not a presOf-bearing content leaf, so this mechanism alone does
+ * not yet reach it). A single-anchor forEach (or none at all) still produces
+ * exactly ONE candidate, `iteration=0, iterationCount=1`, with
+ * `iterationPosition` `undefined` (no per-iteration position exists).
+ *
+ * `inheritedOrigin` (round 32): the nearest ENCLOSING repeated-item-template
+ * node's own `forEachOrigin`, threaded down for a `presOf`-bearing
+ * descendant that has NO `forEachOrigin` of its own -
+ * `continuous-arrow-process--hier5.pptx`'s `parTx`/`desTx` sit two
+ * `dgm:layoutNode` levels inside `linV` (the actual `alg="lin"` item
+ * template, reached via `axis="ch" ptType="node"`), so neither carries a
+ * `forEachOrigin` itself; without this, both resolved root-relatively (one
+ * arbitrary point instead of one per top-level point), collapsing the whole
+ * slot to a single shape. Established ONLY when a bare node's OWN algorithm
+ * is a genuine structural type ({@link STRUCTURAL_ALG_TYPES}) reached
+ * through an `axis="ch" ptType="node"` origin - the narrow "this bare node
+ * IS a repeated per-point item template" signal, not "any bare node with
+ * any forEachOrigin" - so a plain content leaf reached the same way
+ * (unaffected before this round) keeps resolving exactly as before.
+ */
+export declare function collectRawCandidates(node: DiagramLayoutNode, flat: DiagramNode[], declaringRole: string, out?: RawSlotCandidate[], inheritedOrigin?: DiagramIteratorAttributes, ancestorChain?: readonly string[]): RawSlotCandidate[];
+//# sourceMappingURL=smartart-layout-interpreter-composite-candidates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-composite-candidates.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-composite-candidates.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAS1F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AA0F5F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,WAAW,EAAE,EACnB,aAAa,EAAE,MAAM,EACrB,GAAG,GAAE,gBAAgB,EAAO,EAC5B,eAAe,CAAC,EAAE,yBAAyB,EAM3C,aAAa,GAAE,SAAS,MAAM,EAAO,GACnC,gBAAgB,EAAE,CAsEpB"}