@fern-api/fdr-sdk 1.2.42-54880bfeac → 1.2.42-6d01f91096

package/dist/navigation/ledger-root-builder.js

@@ -1,5 +1,4 @@
 import * as FernNavigation from "./index.js";
-import { stripSyntheticSegments } from "./utils/syntheticSectionPath.js";
 const STRUCTURAL_SEGMENT_TYPES = new Set([
     "section",
     "apiReference",
@@ -60,41 +59,6 @@ function metaStr(metadata, key) {
     }
     return undefined;
 }
-/**
- * V1 availability values stored in ledger metadata are lowercase (e.g. "deprecated"),
- * but the latest Availability type uses PascalCase (e.g. "Deprecated"). This map
- * normalises both formats so the badge component can look up display names correctly.
- */
-const AVAILABILITY_LOOKUP = {
-    // V1 lowercase values (stored by docsPublishTransform from V1 navigation tree)
-    alpha: FernNavigation.Availability.Alpha,
-    stable: FernNavigation.Availability.Stable,
-    "generally-available": FernNavigation.Availability.GenerallyAvailable,
-    "in-development": FernNavigation.Availability.InDevelopment,
-    "pre-release": FernNavigation.Availability.PreRelease,
-    deprecated: FernNavigation.Availability.Deprecated,
-    beta: FernNavigation.Availability.Beta,
-    preview: FernNavigation.Availability.Preview,
-    legacy: FernNavigation.Availability.Legacy,
-    // Latest PascalCase values (pass-through)
-    Alpha: FernNavigation.Availability.Alpha,
-    Stable: FernNavigation.Availability.Stable,
-    GenerallyAvailable: FernNavigation.Availability.GenerallyAvailable,
-    InDevelopment: FernNavigation.Availability.InDevelopment,
-    PreRelease: FernNavigation.Availability.PreRelease,
-    Deprecated: FernNavigation.Availability.Deprecated,
-    Beta: FernNavigation.Availability.Beta,
-    Preview: FernNavigation.Availability.Preview,
-    Legacy: FernNavigation.Availability.Legacy
-};
-/** Read an availability field from metadata, converting V1 lowercase to latest PascalCase. */
-function metaAvailability(metadata) {
-    const raw = metaStr(metadata, "availability");
-    if (raw == null) {
-        return undefined;
-    }
-    return AVAILABILITY_LOOKUP[raw];
-}
 function metaBool(metadata, key) {
     if (metadata != null && typeof metadata === "object" && key in metadata) {
         const v = metadata[key];
@@ -233,7 +197,7 @@ function artifactToNode(ctx, route) {
                 }),
                 pageId: FernNavigation.PageId(pageId),
                 noindex: metaBool(md, "noindex"),
-                availability: metaAvailability(md)
+                availability: metaStr(md, "availability")
             };
             return node;
         }
@@ -304,7 +268,7 @@ function apiLeafNodeFromNavRouteInternal(ctx, route, segmentApiDefinitionId) {
             endpointId: FernNavigation.EndpointId(endpointId),
             apiDefinitionId,
             isResponseStream: metaBool(md, "isResponseStream"),
-            availability: metaAvailability(md),
+            availability: metaStr(md, "availability"),
             playground: undefined
         };
     }
@@ -320,7 +284,7 @@ function apiLeafNodeFromNavRouteInternal(ctx, route, segmentApiDefinitionId) {
             method: method,
             webhookId: FernNavigation.WebhookId(webhookId),
             apiDefinitionId,
-            availability: metaAvailability(md)
+            availability: metaStr(md, "availability")
         };
     }
     if (route.type === "asyncapi") {
@@ -333,7 +297,7 @@ function apiLeafNodeFromNavRouteInternal(ctx, route, segmentApiDefinitionId) {
             ...meta,
             webSocketId: FernNavigation.WebSocketId(webSocketId),
             apiDefinitionId,
-            availability: metaAvailability(md),
+            availability: metaStr(md, "availability"),
             playground: undefined
         };
     }
@@ -349,7 +313,7 @@ function apiLeafNodeFromNavRouteInternal(ctx, route, segmentApiDefinitionId) {
             method: method,
             grpcId: FernNavigation.GrpcId(grpcId),
             apiDefinitionId,
-            availability: metaAvailability(md)
+            availability: metaStr(md, "availability")
         };
     }
     if (route.type === "graphql") {
@@ -365,7 +329,7 @@ function apiLeafNodeFromNavRouteInternal(ctx, route, segmentApiDefinitionId) {
             graphqlOperationId: FernNavigation.GraphQlOperationId(graphqlOperationId),
             graphqlOperationIds: undefined,
             apiDefinitionId,
-            availability: metaAvailability(md),
+            availability: metaStr(md, "availability"),
             playground: undefined
         };
     }
@@ -553,8 +517,7 @@ function structuralNodeSlug(ctx, overviewFullPath, section, scopePrefix) {
     // basepath-absolute (it is the version/product/tab node's slug), so join it
     // directly rather than going through `contentSlug` (which would re-prefix
     // the basepath).
-    const cleanSection = stripSyntheticSegments(section);
-    return cleanSection !== "" ? FernNavigation.slugjoin(scopePrefix, cleanSection) : scopePrefix;
+    return section !== "" ? FernNavigation.slugjoin(scopePrefix, section) : scopePrefix;
 }
 function stripLeadingScopePrefix(section, scopePrefix) {
     const prefix = scopePrefix;
@@ -569,30 +532,6 @@ function stripLeadingScopePrefix(section, scopePrefix) {
     }
     return section;
 }
-function computeDuplicateSiblingSortBoundaries(siblings) {
-    const result = new Map();
-    const byPath = new Map();
-    for (const sibling of siblings) {
-        if (metaStr(sibling.seg.metadata, "type") !== "section") {
-            continue;
-        }
-        const group = byPath.get(sibling.seg.section) ?? [];
-        group.push(sibling);
-        byPath.set(sibling.seg.section, group);
-    }
-    for (const [, group] of byPath) {
-        if (group.length <= 1) {
-            continue;
-        }
-        for (let i = 0; i < group.length; i++) {
-            result.set(group[i], {
-                lo: group[i].seg.sortOrder,
-                hi: i + 1 < group.length ? group[i + 1].seg.sortOrder : Number.MAX_SAFE_INTEGER
-            });
-        }
-    }
-    return result;
-}
 /**
  * Merge leaf children and section children by their original V1 tree position.
  * Leaves carry position via `displaySortOrder` (stored in nav routes), sections
@@ -656,7 +595,7 @@ function sectionNode(ctx, scoped, sectionChildren, scopePrefix) {
         noindex: metaBool(overview?.metadata, "noindex") ?? metaBool(seg.metadata, "noindex"),
         collapsible: metaBool(seg.metadata, "collapsible") ?? (metaCollapsed(seg.metadata) === true ? true : undefined),
         collapsedByDefault: metaBool(seg.metadata, "collapsedByDefault") ?? (metaCollapsed(seg.metadata) === true ? true : undefined),
-        availability: metaAvailability(seg.metadata),
+        availability: metaStr(seg.metadata, "availability"),
         pointsTo: metaPointsTo != null ? pointsToSlug(metaPointsTo) : undefined,
         children: mergeChildrenByPosition(ctx, nav, sectionChildren)
     };
@@ -666,16 +605,13 @@ function sectionNode(ctx, scoped, sectionChildren, scopePrefix) {
  * `parentSectionPath(seg.section) === parentSection`, or is an orphaned segment
  * whose nearest existing ancestor is `parentSection`.
  */
-function directChildApiPackages(parentSection, scopeSegs, apiDefinitionId) {
+function directChildApiPackages(parentSection, scopeSegs) {
     const sectionPaths = new Set(scopeSegs.map((s) => s.seg.section));
     return scopeSegs
         .filter((s) => {
         if (metaStr(s.seg.metadata, "type") !== "apiPackage") {
             return false;
         }
-        if (metaStr(s.seg.metadata, "apiDefinitionId") !== apiDefinitionId) {
-            return false;
-        }
         const parent = parentSectionPath(s.seg.section);
         if (parent === parentSection) {
             return true;
@@ -700,37 +636,11 @@ function buildApiChildren(ctx, scoped, scopeSegs, apiDefinitionId, scopePrefix)
     // API leaf types.
     const leafNodes = positionedApiLeafChildren(ctx, nav, apiDefinitionId);
     // Build nested ApiPackageNodes from direct child apiPackage segments.
-    let childPackages = directChildApiPackages(seg.section, scopeSegs, apiDefinitionId);
-    // When multiple API-type segments share the same section path (skipUrlSlug
-    // group packages that collapse to their parent's section), children from
-    // different groups get mixed together. Scope children to this segment's DFS
-    // subtree using sortOrder boundaries to restore correct ownership.
-    const samePathApiSiblings = scopeSegs.filter((s) => s.seg.section === seg.section &&
-        s.seg.sortOrder !== seg.sortOrder &&
-        API_NODE_SEGMENT_TYPES.has(metaStr(s.seg.metadata, "type") ?? ""));
-    const hasCollapsedGroups = samePathApiSiblings.length > 0;
-    if (hasCollapsedGroups && metaStr(seg.metadata, "type") !== "apiReference") {
-        // This is a group package sharing its section with siblings.
-        // Only claim children whose sortOrder falls within our DFS subtree.
-        const nextSibling = samePathApiSiblings
-            .filter((s) => s.seg.sortOrder > seg.sortOrder)
-            .sort((a, b) => a.seg.sortOrder - b.seg.sortOrder)[0];
-        const lo = seg.sortOrder;
-        const hi = nextSibling?.seg.sortOrder ?? Number.MAX_SAFE_INTEGER;
-        childPackages = childPackages.filter((c) => c.seg.sortOrder > lo && c.seg.sortOrder < hi);
-    }
+    const childPackages = directChildApiPackages(seg.section, scopeSegs);
     const packageNodes = childPackages.map((child) => ({
         node: apiPackageChildNode(ctx, child, scopeSegs, apiDefinitionId, scopePrefix),
         childIndex: metaNum(child.seg.metadata, "childIndex")
     }));
-    // When collapsed groups are detected at apiReference level, children's
-    // childIndex values are relative to different parent groups and cannot be
-    // used for interleaving. Fall back to sortOrder (DFS creation order).
-    if (hasCollapsedGroups && metaStr(seg.metadata, "type") === "apiReference") {
-        return [...leafNodes, ...packageNodes.map((p, i) => ({ node: p.node, pos: leafNodes.length + i }))]
-            .sort((a, b) => a.pos - b.pos)
-            .map((p) => p.node);
-    }
     // Interleave by position when childIndex metadata is available
     const hasChildIndex = packageNodes.some((p) => p.childIndex != null);
     if (!hasChildIndex) {
@@ -774,7 +684,7 @@ function apiPackageChildNode(ctx, scoped, scopeSegs, parentApiDefinitionId, scop
             featureFlags: metaFeatureFlags(seg.metadata)
         }),
         apiDefinitionId: FernNavigation.ApiDefinitionId(apiDefinitionId),
-        availability: metaAvailability(seg.metadata),
+        availability: metaStr(seg.metadata, "availability"),
         overviewPageId: overviewPageId != null ? FernNavigation.PageId(overviewPageId) : undefined,
         noindex: metaBool(overview?.metadata, "noindex") ?? metaBool(seg.metadata, "noindex"),
         pointsTo: metaPointsTo != null ? pointsToSlug(metaPointsTo) : undefined,
@@ -884,10 +794,10 @@ function apiReferenceNode(ctx, scoped, scopeSegs, scopePrefix) {
             featureFlags: metaFeatureFlags(seg.metadata)
         }),
         apiDefinitionId: FernNavigation.ApiDefinitionId(apiDefinitionId),
-        availability: metaAvailability(seg.metadata),
+        availability: metaStr(seg.metadata, "availability"),
         overviewPageId: overviewPageId != null ? FernNavigation.PageId(overviewPageId) : undefined,
         noindex: metaBool(overview?.metadata, "noindex") ?? metaBool(seg.metadata, "noindex"),
-        paginated: metaBool(seg.metadata, "paginated"),
+        paginated: true,
         showErrors: metaBool(seg.metadata, "showErrors"),
         hideTitle: metaBool(seg.metadata, "hideTitle"),
         pointsTo: metaPointsTo != null ? pointsToSlug(metaPointsTo) : undefined,
@@ -905,12 +815,7 @@ function attachedApiChangelogNode(ctx, scoped, scopeSegs, apiDefinitionId, scope
         }
         return metaStr(candidate.seg.metadata, "apiDefinitionId") === apiDefinitionId;
     });
-    const apiReferenceCount = scopeSegs.filter((candidate) => {
-        return (metaStr(candidate.seg.metadata, "type") === "apiReference" &&
-            metaStr(candidate.seg.metadata, "apiDefinitionId") === apiDefinitionId);
-    }).length;
-    const changelogSeg = candidates.find((candidate) => parentSectionPath(candidate.seg.section) === seg.section) ??
-        (apiReferenceCount === 1 ? candidates[0] : undefined);
+    const changelogSeg = candidates.find((candidate) => parentSectionPath(candidate.seg.section) === seg.section) ?? candidates[0];
     return changelogSeg != null ? changelogNode(ctx, changelogSeg, scopePrefix) : undefined;
 }
 function hasOwningApiReference(scoped, scopeSegs) {
@@ -918,68 +823,12 @@ function hasOwningApiReference(scoped, scopeSegs) {
     if (apiDefinitionId == null || metaStr(scoped.seg.metadata, "type") !== "changelog") {
         return false;
     }
-    const candidates = scopeSegs.filter((candidate) => {
+    return scopeSegs.some((candidate) => {
         if (metaStr(candidate.seg.metadata, "type") !== "apiReference") {
             return false;
         }
         return metaStr(candidate.seg.metadata, "apiDefinitionId") === apiDefinitionId;
     });
-    return (candidates.some((candidate) => parentSectionPath(scoped.seg.section) === candidate.seg.section) ||
-        candidates.length === 1);
-}
-/**
- * True when this segment is an `apiPackage` that will be nested under an in-scope
- * `apiReference` for the same API by {@link buildApiChildren}, and therefore must
- * NOT also be emitted as a standalone root/section node.
- *
- * Without this guard, a skip-slug apiReference (section "") leaves its resource
- * subpackages with `parentSectionPath === ""`, so they look root-level and get
- * emitted a second time as always-expanded top-level apiReference nodes —
- * duplicating every resource and endpoint in the sidebar (the "67 apiReference
- * nodes vs 1" API-reference regression).
- *
- * Reachability mirrors {@link directChildApiPackages}: walk up the section-path
- * chain (hopping to nearestExistingAncestor when a parent section is absent)
- * until we reach an apiReference's section. If no apiReference is an ancestor the
- * package is left where it is, so it can never be dropped.
- */
-function isNestedApiPackage(scoped, scopeSegs) {
-    if (metaStr(scoped.seg.metadata, "type") !== "apiPackage") {
-        return false;
-    }
-    const apiDefinitionId = metaStr(scoped.seg.metadata, "apiDefinitionId");
-    if (apiDefinitionId == null) {
-        return false;
-    }
-    const apiReferenceSections = new Set(scopeSegs
-        .filter((s) => metaStr(s.seg.metadata, "type") === "apiReference" &&
-        metaStr(s.seg.metadata, "apiDefinitionId") === apiDefinitionId)
-        .map((s) => s.seg.section));
-    if (apiReferenceSections.size === 0) {
-        return false;
-    }
-    const sectionPaths = new Set(scopeSegs.map((s) => s.seg.section));
-    const resolveParent = (section) => {
-        const parent = parentSectionPath(section);
-        if (parent === "" || sectionPaths.has(parent)) {
-            return parent;
-        }
-        return nearestExistingAncestor(section, sectionPaths);
-    };
-    let current = scoped.seg.section;
-    const seen = new Set([current]);
-    // Walk up until we hit an owning apiReference (nested → true) or run out.
-    for (;;) {
-        const parent = resolveParent(current);
-        if (apiReferenceSections.has(parent)) {
-            return true;
-        }
-        if (parent === "" || seen.has(parent)) {
-            return false;
-        }
-        seen.add(parent);
-        current = parent;
-    }
 }
 function changelogNode(ctx, scoped, scopePrefix) {
     const { seg, nav } = scoped;
@@ -1103,13 +952,7 @@ function buildSectionTree(ctx, scopeSegs, parentPath, scopePrefix, changelogScop
         if (sec === "" || type === "tabRoot") {
             return false;
         }
-        if (hasOwningApiReference(s, scopeSegs) || isNestedApiPackage(s, scopeSegs)) {
-            return false;
-        }
-        // Segments marked as sidebar depth 0 are V1 root-level peers and
-        // must never be adopted as children of another section.
-        const depth = metaNum(s.seg.metadata, "sidebarDepth");
-        if (depth === 0) {
+        if (hasOwningApiReference(s, scopeSegs)) {
             return false;
         }
         const parent = parentSectionPath(sec);
@@ -1124,7 +967,6 @@ function buildSectionTree(ctx, scopeSegs, parentPath, scopePrefix, changelogScop
         return false;
     })
         .sort((a, b) => a.seg.sortOrder - b.seg.sortOrder);
-    const siblingBoundaries = computeDuplicateSiblingSortBoundaries(direct);
     return direct.map((s) => {
         const type = metaStr(s.seg.metadata, "type");
         const childIndex = metaNum(s.seg.metadata, "childIndex");
@@ -1137,11 +979,7 @@ function buildSectionTree(ctx, scopeSegs, parentPath, scopePrefix, changelogScop
         }
         else {
             // section (or unrecognised) → recurse for nested sections.
-            const boundary = siblingBoundaries.get(s);
-            const childScopeSegs = boundary != null
-                ? scopeSegs.filter((candidate) => candidate.seg.sortOrder >= boundary.lo && candidate.seg.sortOrder < boundary.hi)
-                : scopeSegs;
-            node = sectionNode(ctx, s, buildSectionTree(ctx, childScopeSegs, s.seg.section, scopePrefix, changelogScopePrefix), scopePrefix);
+            node = sectionNode(ctx, s, buildSectionTree(ctx, scopeSegs, s.seg.section, scopePrefix, changelogScopePrefix), scopePrefix);
         }
         return { node, childIndex };
     });
@@ -1161,26 +999,16 @@ function buildSectionTree(ctx, scopeSegs, parentPath, scopePrefix, changelogScop
 function computeSiblingSortBoundaries(ordered) {
     const result = new Map();
     // Collect root-level sections grouped by their section path.
-    // Sections with sec==="" (skip-slug sections) are included: when multiple
-    // skip-slug sections exist at the root, they share path "" and need
-    // boundaries so each only adopts its own children.
     const sectionPaths = new Set(ordered.map((s) => s.seg.section));
     const rootSections = [];
     for (const s of ordered) {
         const type = metaStr(s.seg.metadata, "type");
         const sec = s.seg.section;
-        if (type !== "section") {
-            continue;
-        }
-        if (sec === "") {
-            rootSections.push(s);
+        if (type !== "section" || sec === "") {
             continue;
         }
-        const depth = metaNum(s.seg.metadata, "sidebarDepth");
         const parent = parentSectionPath(sec);
-        const isRootLevel = depth === 0 ||
-            parent === "" ||
-            (!sectionPaths.has(parent) && nearestExistingAncestor(sec, sectionPaths) === "");
+        const isRootLevel = parent === "" || (!sectionPaths.has(parent) && nearestExistingAncestor(sec, sectionPaths) === "");
         if (isRootLevel) {
             rootSections.push(s);
         }
@@ -1225,17 +1053,6 @@ function buildSidebarRootChildren(ctx, scopeSegs, scopePrefix, changelogScopePre
     // segments. Both index into the SAME child list at write time, so they
     // interleave directly (e.g. [page 0, page 1, section 2…15, page 16, 17]).
     const annotated = [];
-    // ── Sibling section ownership ────────────────────────────────────────
-    //
-    // Multiple root-level sections can share the same section path (e.g.
-    // three sections all with path equal to the version slug). When this
-    // happens, buildSectionTree would incorrectly give ALL child subsections
-    // to each sibling. We resolve ownership via sortOrder: a section owns
-    // segments whose sortOrder falls between its own and the next sibling's.
-    //
-    // Computed first because hasRootSection (below) uses it to decide
-    // whether bounded skip-slug siblings should activate adoption.
-    const siblingBoundaries = computeSiblingSortBoundaries(ordered);
     // ── Root-section adoption flow ──────────────────────────────────────
     //
     // A scope may contain a "root section" — a segment with type "section"
@@ -1247,42 +1064,28 @@ function buildSidebarRootChildren(ctx, scopeSegs, scopePrefix, changelogScopePre
     //   │      → emit pages/links inline at their displaySortOrder
     //   │
     //   ├─ (B) the root section itself (sec=="", type=="section")
-    //   │      → buildSectionTree adopts nested children (depth > 0)
-    //   │      → emit one sectionNode wrapping the subtree
+    //   │      → buildSectionTree adopts ALL depth-0 children as its own
+    //   │      → emit one sectionNode wrapping the whole subtree
     //   │
-    //   └─ (C) depth-0 sections (sidebarDepth==0 or parentSectionPath=="")
-    //          → emit directly as root children (not adopted by B)
+    //   └─ (C) depth-0 sections (parentSectionPath=="")
+    //          → SKIP — already adopted by (B) via buildSectionTree
     //
     // Without a root section, depth-0 sections are emitted directly.
+    const hasRootSection = ordered.some((s) => metaStr(s.seg.metadata, "type") === "section" && s.seg.section === "");
+    // ── Sibling section ownership ────────────────────────────────────────
     //
-    // A section with sec=="" AND `childIndex` in its metadata is a sibling
-    // inside a V1 sidebarGroup that has skipUrlSlug — not a true structural
-    // wrapper. `walkNavSubTrees` always passes `childIndex`; direct
-    // sidebarRoot children (true wrappers) never receive one.
-    //
-    // Such siblings only activate adoption when they have sortOrder
-    // boundaries (multiple sec="" sections sharing the same path), which
-    // correctly scope each section's children. A *single* unbounded
-    // skip-slug sibling (e.g. mangopay's "Introduction") must NOT adopt
-    // its depth-0 peers — doing so produces spurious breadcrumb entries.
-    const hasRootSection = ordered.some((s) => metaStr(s.seg.metadata, "type") === "section" &&
-        s.seg.section === "" &&
-        (metaNum(s.seg.metadata, "childIndex") == null || siblingBoundaries.has(s)));
+    // Multiple root-level sections can share the same section path (e.g.
+    // three sections all with path equal to the version slug). When this
+    // happens, buildSectionTree would incorrectly give ALL child subsections
+    // to each sibling. We resolve ownership via sortOrder: a section owns
+    // segments whose sortOrder falls between its own and the next sibling's.
+    const siblingBoundaries = computeSiblingSortBoundaries(ordered);
     for (const s of ordered) {
         const type = metaStr(s.seg.metadata, "type");
         const sec = s.seg.section;
-        if (hasOwningApiReference(s, scopeSegs) || isNestedApiPackage(s, scopeSegs)) {
+        if (hasOwningApiReference(s, scopeSegs)) {
             continue;
         }
-        // Skip apiPackage segments that share their section path with an
-        // apiReference sibling (skipUrlSlug structural wrappers). Their
-        // children are already claimed by the apiReference via DFS ordering.
-        if (type === "apiPackage") {
-            const hasApiRefSibling = ordered.some((sib) => sib.seg.section === sec && metaStr(sib.seg.metadata, "type") === "apiReference");
-            if (hasApiRefSibling) {
-                continue;
-            }
-        }
         if (type === "tabRoot" && metaBool(s.seg.metadata, "landingPage") === true) {
             continue;
         }
@@ -1299,35 +1102,21 @@ function buildSidebarRootChildren(ctx, scopeSegs, scopePrefix, changelogScopePre
             continue;
         }
         // (B) Root section wrapper — adopts depth-0 children via buildSectionTree.
-        // Only applies to true root wrappers (no childIndex); sibling
-        // sections with skipUrlSlug (have childIndex) fall through to (C).
-        // When multiple sections share sec==="" (skip-slug), scope children
-        // to each section's sortOrder range so subsections aren't duplicated.
-        if (type === "section" && sec === "" && hasRootSection) {
-            const bounds = siblingBoundaries.get(s);
-            const ownedSegs = bounds != null
-                ? scopeSegs.filter((seg) => seg.seg.sortOrder >= bounds.lo && seg.seg.sortOrder < bounds.hi)
-                : scopeSegs;
-            const sectionChildren = buildSectionTree(ctx, ownedSegs, "", scopePrefix, changelogScopePrefix);
+        if (type === "section" && sec === "") {
+            const sectionChildren = buildSectionTree(ctx, scopeSegs, "", scopePrefix);
             const node = sectionNode(ctx, s, sectionChildren, scopePrefix);
             annotated.push({ node, pos: metaNum(s.seg.metadata, "childIndex"), isLeaf: false });
             continue;
         }
         // (C) Depth-0 or orphaned sections — emit at root unless already
         // adopted by a root section (B).
-        const depth = metaNum(s.seg.metadata, "sidebarDepth");
         const parent = parentSectionPath(sec);
-        const isRootLevel = depth === 0 ||
-            parent === "" ||
-            (!sectionPaths.has(parent) && nearestExistingAncestor(sec, sectionPaths) === "");
-        // Skip sections already adopted by the root section wrapper (B).
-        // Sections with sidebarDepth===0 are true V1 root peers that
-        // buildSectionTree now excludes — they must NOT be skipped.
-        // Sections with sidebarDepth>0 are nested children that SHOULD
-        // be adopted, so they must be skipped to avoid duplication.
-        // Sections without sidebarDepth (old data) are also skipped —
-        // they rely on path-based hierarchy in buildSectionTree.
-        if (isRootLevel && hasRootSection && sec !== "" && depth !== 0) {
+        const isRootLevel = parent === "" || (!sectionPaths.has(parent) && nearestExistingAncestor(sec, sectionPaths) === "");
+        // Skip depth-0 sections already adopted by the root section wrapper (B),
+        // but NOT structural types with sec="" (skip-slug). buildSectionTree
+        // filters out sec="" segments (line 1249), so they wouldn't be adopted
+        // and must be emitted here directly.
+        if (isRootLevel && hasRootSection && sec !== "") {
             continue;
         }
         if (isRootLevel) {
@@ -1345,20 +1134,7 @@ function buildSidebarRootChildren(ctx, scopeSegs, scopePrefix, changelogScopePre
                 const ownedSegs = bounds != null
                     ? scopeSegs.filter((seg) => seg.seg.sortOrder >= bounds.lo && seg.seg.sortOrder < bounds.hi)
                     : scopeSegs;
-                // A section with sec="" that reaches here (not adopted as a
-                // root wrapper in case B) is a skipUrlSlug sibling.
-                // When sortOrder boundaries exist (multiple sec="" sections),
-                // the scoped ownedSegs correctly limits which subsections
-                // each section can adopt. When there are NO boundaries
-                // (single sec="" section, e.g. mangopay's "Introduction"),
-                // buildSectionTree("") would re-adopt all depth-0 peers;
-                // pass an empty child list instead — its leaf artifacts are
-                // already in its own segment nav.
-                const isUnboundedSkipSlugSibling = sec === "" && metaNum(s.seg.metadata, "childIndex") != null && bounds == null;
-                const sectionChildren = isUnboundedSkipSlugSibling
-                    ? []
-                    : buildSectionTree(ctx, ownedSegs, sec, scopePrefix, changelogScopePrefix);
-                node = sectionNode(ctx, s, sectionChildren, scopePrefix);
+                node = sectionNode(ctx, s, buildSectionTree(ctx, ownedSegs, sec, scopePrefix, changelogScopePrefix), scopePrefix);
             }
             // Shared/merged sections (paths not rooted in scopePrefix) must not
             // carry childIndex — their source-version positions would sort them
@@ -1428,6 +1204,11 @@ function groupSidebarRootChildren(ctx, children) {
             flushRun();
             out.push(child);
         }
+        else if (child.type === "changelog") {
+            flushRun();
+            run.push(child);
+            flushRun();
+        }
         else {
             run.push(child);
         }
@@ -1594,7 +1375,7 @@ function buildVariantedNode(ctx, variants, scopeSegs, scopePrefix) {
             ? asSlug(FernNavigation.slugjoin(scopePrefix, variantIndividualSlug))
             : scopePrefix;
         const metaPointsTo = metaStr(variant.metadata, "pointsTo");
-        const children = buildSidebarRootChildren(ctx, variantSegs, variantSlug);
+        const children = buildSidebarRootChildren(ctx, variantSegs, scopePrefix);
         return {
             type: "variant",
             ...withMetadataDefaults({
@@ -2130,14 +1911,6 @@ function buildProductGroup(ctx, products, scoped, rootSlug, skipSharedSectionMer
         };
         return node;
     });
-    // Cross-product canonical slug deduplication (V2 parity).
-    // V2's migrator deduplicates pages across products via a global pageId map:
-    // the first product to register a pageId wins, and subsequent products'
-    // pages with the same pageId receive a canonicalSlug pointing to the
-    // canonical (default-product) page. Without this, shared content that is
-    // materialized under every product scope (e.g. merge-api-basics pages)
-    // appears as separate sitemap entries per product.
-    markCrossProductCanonicalSlugs(children);
     return {
         type: "productgroup",
         id: ctx.nodeId("productgroup"),
@@ -2146,43 +1919,5 @@ function buildProductGroup(ctx, products, scoped, rootSlug, skipSharedSectionMer
         children
     };
 }
-/**
- * Deduplicate pages across products using pageId as a content-identity key.
- * Pages with the same pageId in different products are the same content
- * materialized per-scope; the default product's slug becomes canonical and
- * non-default copies receive `canonicalSlug` so the sitemap collapses them.
- *
- * API leaf nodes (endpoints, websockets, etc.) are unaffected — `getPageId`
- * returns undefined for those types, so product-specific API surface is
- * never suppressed.
- */
-function markCrossProductCanonicalSlugs(productNodes) {
-    const pageIdToCanonical = new Map();
-    // Process default product first so its slugs become the canonical targets.
-    const sorted = [...productNodes].sort((a, b) => {
-        if (a.default !== b.default) {
-            return a.default ? -1 : 1;
-        }
-        return 0;
-    });
-    for (const product of sorted) {
-        FernNavigation.traverseDF(product, (child) => {
-            if (FernNavigation.hasMetadata(child) && FernNavigation.isPage(child)) {
-                const pid = FernNavigation.getPageId(child);
-                if (pid == null) {
-                    return;
-                }
-                const key = `pid:${pid}`;
-                const canonical = pageIdToCanonical.get(key);
-                if (canonical != null && !product.default) {
-                    child.canonicalSlug = canonical;
-                }
-                else if (canonical == null) {
-                    pageIdToCanonical.set(key, child.canonicalSlug ?? child.slug);
-                }
-            }
-        });
-    }
-}
 // (root keeps the bare "root" id; it is the single tree root.)
 //# sourceMappingURL=ledger-root-builder.js.map