@savvy-web/changesets 0.4.2 → 0.5.0

package/cjs/markdownlint.cjs

@@ -28,6 +28,7 @@ __webpack_require__.d(__webpack_exports__, {
     HeadingHierarchyRule: ()=>HeadingHierarchyRule,
     UncategorizedContentRule: ()=>UncategorizedContentRule,
     default: ()=>markdownlint,
+    DependencyTableFormatRule: ()=>DependencyTableFormatRule,
     RequiredSectionsRule: ()=>RequiredSectionsRule
 });
 const DOCS_BASE = "https://github.com/savvy-web/changesets/blob/main/docs/rules";
@@ -35,7 +36,8 @@ const RULE_DOCS = {
     CSH001: `${DOCS_BASE}/CSH001.md`,
     CSH002: `${DOCS_BASE}/CSH002.md`,
     CSH003: `${DOCS_BASE}/CSH003.md`,
-    CSH004: `${DOCS_BASE}/CSH004.md`
+    CSH004: `${DOCS_BASE}/CSH004.md`,
+    CSH005: `${DOCS_BASE}/CSH005.md`
 };
 function getHeadingLevel(heading) {
     const sequence = heading.children.find((c)=>"atxHeadingSequence" === c.type);
@@ -104,6 +106,155 @@ const ContentStructureRule = {
         }
     }
 };
+const EM_DASH = "\u2014";
+const VALID_TYPES = new Set([
+    "dependency",
+    "devDependency",
+    "peerDependency",
+    "optionalDependency",
+    "workspace",
+    "config"
+]);
+const VALID_ACTIONS = new Set([
+    "added",
+    "updated",
+    "removed"
+]);
+const EXPECTED_HEADERS = [
+    "dependency",
+    "type",
+    "action",
+    "from",
+    "to"
+];
+const VERSION_RE = /^(\u2014|[~^]?\d+\.\d+\.\d+(?:[-+.][\w.+-]*)?)$/;
+function getCellText(cell) {
+    const content = cell.children.find((c)=>"tableContent" === c.type);
+    return content ? content.text.trim() : "";
+}
+function getRowCells(row) {
+    return row.children.filter((c)=>"tableHeader" === c.type || "tableData" === c.type).map(getCellText);
+}
+const DependencyTableFormatRule = {
+    names: [
+        "changeset-dependency-table-format",
+        "CSH005"
+    ],
+    description: "Dependencies section must contain a valid dependency table",
+    tags: [
+        "changeset"
+    ],
+    parser: "micromark",
+    function: function(params, onError) {
+        const tokens = params.parsers.micromark.tokens;
+        for(let i = 0; i < tokens.length; i++){
+            const token = tokens[i];
+            if ("atxHeading" !== token.type) continue;
+            if (2 !== getHeadingLevel(token)) continue;
+            if ("dependencies" !== getHeadingText(token).toLowerCase()) continue;
+            const headingLine = token.startLine;
+            let tableToken = null;
+            for(let j = i + 1; j < tokens.length; j++){
+                const next = tokens[j];
+                if ("lineEnding" !== next.type && "lineEndingBlank" !== next.type) {
+                    if ("atxHeading" === next.type) break;
+                    if ("table" === next.type) tableToken = next;
+                    break;
+                }
+            }
+            if (null === tableToken) {
+                onError({
+                    lineNumber: headingLine,
+                    detail: `Dependencies section must contain a table, not a list or paragraph. See: ${RULE_DOCS.CSH005}`
+                });
+                continue;
+            }
+            const tableHead = tableToken.children.find((c)=>"tableHead" === c.type);
+            if (!tableHead) {
+                onError({
+                    lineNumber: tableToken.startLine,
+                    detail: `Dependencies table is missing a header row. See: ${RULE_DOCS.CSH005}`
+                });
+                continue;
+            }
+            const headerRow = tableHead.children.find((c)=>"tableRow" === c.type);
+            if (!headerRow) {
+                onError({
+                    lineNumber: tableToken.startLine,
+                    detail: `Dependencies table is missing a header row. See: ${RULE_DOCS.CSH005}`
+                });
+                continue;
+            }
+            const headers = getRowCells(headerRow).map((h)=>h.toLowerCase());
+            if (headers.length !== EXPECTED_HEADERS.length || !headers.every((h, idx)=>h === EXPECTED_HEADERS[idx])) {
+                onError({
+                    lineNumber: headerRow.startLine,
+                    detail: `Dependencies table must have columns: Dependency, Type, Action, From, To. Got: ${headers.join(", ")}. See: ${RULE_DOCS.CSH005}`
+                });
+                continue;
+            }
+            const tableBody = tableToken.children.find((c)=>"tableBody" === c.type);
+            if (!tableBody) {
+                onError({
+                    lineNumber: tableToken.startLine,
+                    detail: `Dependencies table must have at least one data row. See: ${RULE_DOCS.CSH005}`
+                });
+                continue;
+            }
+            const dataRows = tableBody.children.filter((c)=>"tableRow" === c.type);
+            if (0 === dataRows.length) {
+                onError({
+                    lineNumber: tableToken.startLine,
+                    detail: `Dependencies table must have at least one data row. See: ${RULE_DOCS.CSH005}`
+                });
+                continue;
+            }
+            for (const row of dataRows){
+                const cells = getRowCells(row);
+                if (cells.length < 5) {
+                    onError({
+                        lineNumber: row.startLine,
+                        detail: `Dependencies table row has too few columns (expected 5, got ${cells.length}). See: ${RULE_DOCS.CSH005}`
+                    });
+                    continue;
+                }
+                const [dependency, type, action, from, to] = cells;
+                if (!dependency) onError({
+                    lineNumber: row.startLine,
+                    detail: `Dependencies table row has an empty 'Dependency' cell. See: ${RULE_DOCS.CSH005}`
+                });
+                if (!VALID_TYPES.has(type)) onError({
+                    lineNumber: row.startLine,
+                    detail: `Invalid dependency type '${type}'. Valid types are: ${[
+                        ...VALID_TYPES
+                    ].join(", ")}. See: ${RULE_DOCS.CSH005}`
+                });
+                if (!VALID_ACTIONS.has(action)) onError({
+                    lineNumber: row.startLine,
+                    detail: `Invalid dependency action '${action}'. Valid actions are: ${[
+                        ...VALID_ACTIONS
+                    ].join(", ")}. See: ${RULE_DOCS.CSH005}`
+                });
+                if (from && !VERSION_RE.test(from)) onError({
+                    lineNumber: row.startLine,
+                    detail: `Invalid 'from' value '${from}'. Must be a semver string or em dash (\u2014). See: ${RULE_DOCS.CSH005}`
+                });
+                if (to && !VERSION_RE.test(to)) onError({
+                    lineNumber: row.startLine,
+                    detail: `Invalid 'to' value '${to}'. Must be a semver string or em dash (\u2014). See: ${RULE_DOCS.CSH005}`
+                });
+                if ("added" === action && from !== EM_DASH) onError({
+                    lineNumber: row.startLine,
+                    detail: `'from' must be '\u2014' when action is 'added' (got '${from}'). See: ${RULE_DOCS.CSH005}`
+                });
+                if ("removed" === action && to !== EM_DASH) onError({
+                    lineNumber: row.startLine,
+                    detail: `'to' must be '\u2014' when action is 'removed' (got '${to}'). See: ${RULE_DOCS.CSH005}`
+                });
+            }
+        }
+    }
+};
 const HeadingHierarchyRule = {
     names: [
         "changeset-heading-hierarchy",
@@ -311,16 +462,19 @@ const SilkChangesetsRules = [
     HeadingHierarchyRule,
     RequiredSectionsRule,
     ContentStructureRule,
-    UncategorizedContentRule
+    UncategorizedContentRule,
+    DependencyTableFormatRule
 ];
 const markdownlint = SilkChangesetsRules;
 exports.ContentStructureRule = __webpack_exports__.ContentStructureRule;
+exports.DependencyTableFormatRule = __webpack_exports__.DependencyTableFormatRule;
 exports.HeadingHierarchyRule = __webpack_exports__.HeadingHierarchyRule;
 exports.RequiredSectionsRule = __webpack_exports__.RequiredSectionsRule;
 exports.UncategorizedContentRule = __webpack_exports__.UncategorizedContentRule;
 exports["default"] = __webpack_exports__["default"];
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ContentStructureRule",
+    "DependencyTableFormatRule",
     "HeadingHierarchyRule",
     "RequiredSectionsRule",
     "UncategorizedContentRule",

package/cjs/markdownlint.d.cts

@@ -1,14 +1,24 @@
 /**
+ * \@savvy-web/changesets/markdownlint
+ *
  * markdownlint custom rules for validating changeset file structure.
  *
  * Provides the same validation as the remark-lint rules but using
  * markdownlint's micromark token API for integration with
  * markdownlint-cli2 and the VS Code markdownlint extension.
  *
- * - `changeset-heading-hierarchy` (CSH001): Enforce h2 start, no h1, no depth skips
- * - `changeset-required-sections` (CSH002): Validate section headings match known categories
- * - `changeset-content-structure` (CSH003): Content quality validation
- * - `changeset-uncategorized-content` (CSH004): Reject content before first h2 heading
+ * Rules included:
+ * - {@link HeadingHierarchyRule | changeset-heading-hierarchy} (CSH001): Enforce h2 start, no h1, no depth skips
+ * - {@link RequiredSectionsRule | changeset-required-sections} (CSH002): Validate section headings match known categories
+ * - {@link ContentStructureRule | changeset-content-structure} (CSH003): Content quality validation
+ * - {@link UncategorizedContentRule | changeset-uncategorized-content} (CSH004): Reject content before first h2 heading
+ * - {@link DependencyTableFormatRule | changeset-dependency-table-format} (CSH005): Validate dependency table structure
+ *
+ * @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH001.md | CSH001 docs}
+ * @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH002.md | CSH002 docs}
+ * @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH003.md | CSH003 docs}
+ * @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH004.md | CSH004 docs}
+ * @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH005.md | CSH005 docs}
  *
  * @packageDocumentation
  */
@@ -16,31 +26,103 @@
 import type { Rule } from 'markdownlint';
 
 /**
- * markdownlint rule: changeset-content-structure (CSH003)
+ * markdownlint rule: `changeset-content-structure` (CSH003).
+ *
+ * Validates content quality inside changeset markdown files by inspecting
+ * micromark tokens for three categories of structural problems:
+ *
+ * 1. **Empty sections** -- an `atxHeading` (h2) followed immediately by another
+ *    h2 or the end of the token stream with no intervening content tokens.
+ * 2. **Code blocks without a language identifier** -- a `codeFenced` token whose
+ *    opening fence child lacks a `codeFencedFenceInfo` token.
+ * 3. **Empty list items** -- a `listItemPrefix` token with no subsequent
+ *    `content` token before the next prefix or end of list.
  *
- * Validates content quality in changeset files:
- * - Sections must not be empty (h2 followed immediately by another h2 or EOF)
- * - Code blocks must have a language identifier
- * - List items should have meaningful content (not empty)
+ * @remarks
+ * This rule mirrors the remark-lint rule `remarkLintContentStructure` but uses
+ * markdownlint's micromark token API so it can run inside markdownlint-cli2 and
+ * the VS Code markdownlint extension.
+ *
+ * @example
+ * ```json
+ * {
+ *   "changeset-content-structure": true
+ * }
+ * ```
+ *
+ * @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH003.md | CSH003 rule documentation}
+ * @see `src/remark/rules/content-structure.ts` for the corresponding remark-lint rule
+ *
+ * @public
  */
 export declare const ContentStructureRule: Rule;
 
 /**
- * markdownlint rule: changeset-heading-hierarchy (CSH001)
+ * The markdownlint `Rule` object for CSH005 (`changeset-dependency-table-format`).
+ *
+ * @public
+ */
+export declare const DependencyTableFormatRule: Rule;
+
+/**
+ * markdownlint rule: `changeset-heading-hierarchy` (CSH001).
+ *
+ * Validates heading structure in changeset markdown files by inspecting
+ * `atxHeading` micromark tokens for three constraints:
+ *
+ * 1. **No h1 headings** -- h1 is reserved for the version title generated by
+ *    the changelog formatter.
+ * 2. **Start at h2** -- the first heading in a changeset must be h2.
+ * 3. **No depth skips** -- heading levels must increase sequentially
+ *    (h2 then h3, not h2 then h4).
+ *
+ * @remarks
+ * This rule mirrors the remark-lint rule `remarkLintHeadingHierarchy` but uses
+ * markdownlint's micromark token API so it can run inside markdownlint-cli2 and
+ * the VS Code markdownlint extension.
+ *
+ * @example
+ * ```json
+ * {
+ *   "changeset-heading-hierarchy": true
+ * }
+ * ```
+ *
+ * @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH001.md | CSH001 rule documentation}
+ * @see `src/remark/rules/heading-hierarchy.ts` for the corresponding remark-lint rule
  *
- * Validates heading structure in changeset files:
- * - No h1 headings allowed
- * - Headings must start at h2
- * - No depth skips (e.g., h2 ... h4 is invalid)
+ * @public
  */
 export declare const HeadingHierarchyRule: Rule;
 
 /**
- * markdownlint rule: changeset-required-sections (CSH002)
+ * markdownlint rule: `changeset-required-sections` (CSH002).
+ *
+ * Validates that every h2 (`atxHeading` with depth 2) in a changeset markdown
+ * file matches a known category heading from the category system. When an
+ * unrecognized heading is found, the error detail lists all valid headings.
+ *
+ * @remarks
+ * Heading comparison is case-insensitive. The set of valid headings is provided
+ * by `allHeadings()` and `isValidHeading()` from the category system
+ * (`src/categories/index.ts`). This rule inspects `atxHeading` micromark
+ * tokens and extracts their text via the {@link getHeadingText} utility.
+ *
+ * This rule mirrors the remark-lint rule `remarkLintRequiredSections` but uses
+ * markdownlint's micromark token API so it can run inside markdownlint-cli2 and
+ * the VS Code markdownlint extension.
+ *
+ * @example
+ * ```json
+ * {
+ *   "changeset-required-sections": true
+ * }
+ * ```
+ *
+ * @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH002.md | CSH002 rule documentation}
+ * @see `src/remark/rules/required-sections.ts` for the corresponding remark-lint rule
  *
- * Validates that all h2 headings in changeset files match a known
- * category heading from the category system. Reports unrecognized
- * headings with the list of valid options.
+ * @public
  */
 export declare const RequiredSectionsRule: Rule;
 
@@ -60,10 +142,34 @@ declare const SilkChangesetsRules: Rule[];
 export default SilkChangesetsRules;
 
 /**
- * markdownlint rule: changeset-uncategorized-content (CSH004)
+ * markdownlint rule: `changeset-uncategorized-content` (CSH004).
+ *
+ * Detects content that appears before the first h2 heading in a changeset
+ * markdown file. All substantive content must be placed under a categorized
+ * section (`## heading`).
  *
- * Detects content that appears before the first h2 heading in a changeset file.
- * All content must be placed under a categorized section (## heading).
+ * @remarks
+ * The rule iterates over the top-level micromark token stream and stops at the
+ * first `atxHeading` with depth 2. Any token encountered before that heading
+ * that is not a `lineEnding`, `lineEndingBlank`, or `htmlFlow` (HTML comments)
+ * triggers an error. This ensures that changeset content is always grouped
+ * under a recognized category heading.
+ *
+ * This rule mirrors the remark-lint rule `remarkLintUncategorizedContent` but
+ * uses markdownlint's micromark token API so it can run inside
+ * markdownlint-cli2 and the VS Code markdownlint extension.
+ *
+ * @example
+ * ```json
+ * {
+ *   "changeset-uncategorized-content": true
+ * }
+ * ```
+ *
+ * @see {@link https://github.com/savvy-web/changesets/blob/main/docs/rules/CSH004.md | CSH004 rule documentation}
+ * @see `src/remark/rules/uncategorized-content.ts` for the corresponding remark-lint rule
+ *
+ * @public
  */
 export declare const UncategorizedContentRule: Rule;
 

package/cjs/remark.cjs

@@ -24,21 +24,161 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    RequiredSectionsRule: ()=>RequiredSectionsRule,
+    SilkChangesetPreset: ()=>SilkChangesetPreset,
     UncategorizedContentRule: ()=>UncategorizedContentRule,
     SilkChangesetTransformPreset: ()=>SilkChangesetTransformPreset,
-    NormalizeFormatPlugin: ()=>NormalizeFormatPlugin,
+    DependencyTableFormatRule: ()=>DependencyTableFormatRule,
     IssueLinkRefsPlugin: ()=>IssueLinkRefsPlugin,
-    MergeSectionsPlugin: ()=>MergeSectionsPlugin,
+    DeduplicateItemsPlugin: ()=>DeduplicateItemsPlugin,
     ContentStructureRule: ()=>ContentStructureRule,
     HeadingHierarchyRule: ()=>HeadingHierarchyRule,
-    DeduplicateItemsPlugin: ()=>DeduplicateItemsPlugin,
-    ReorderSectionsPlugin: ()=>ReorderSectionsPlugin,
+    AggregateDependencyTablesPlugin: ()=>AggregateDependencyTablesPlugin,
+    MergeSectionsPlugin: ()=>MergeSectionsPlugin,
     ContributorFootnotesPlugin: ()=>ContributorFootnotesPlugin,
-    SilkChangesetPreset: ()=>SilkChangesetPreset,
-    RequiredSectionsRule: ()=>RequiredSectionsRule
+    NormalizeFormatPlugin: ()=>NormalizeFormatPlugin,
+    ReorderSectionsPlugin: ()=>ReorderSectionsPlugin
 });
-const external_unist_util_visit_namespaceObject = require("unist-util-visit");
+const external_effect_namespaceObject = require("effect");
 const external_mdast_util_to_string_namespaceObject = require("mdast-util-to-string");
+require("remark-gfm");
+require("remark-stringify");
+require("unified");
+const NonEmptyString = external_effect_namespaceObject.Schema.String.pipe(external_effect_namespaceObject.Schema.minLength(1));
+external_effect_namespaceObject.Schema.Number.pipe(external_effect_namespaceObject.Schema.int(), external_effect_namespaceObject.Schema.positive());
+const DependencyActionSchema = external_effect_namespaceObject.Schema.Literal("added", "updated", "removed");
+const DependencyTableTypeSchema = external_effect_namespaceObject.Schema.Literal("dependency", "devDependency", "peerDependency", "optionalDependency", "workspace", "config");
+const VersionOrEmptySchema = external_effect_namespaceObject.Schema.String.pipe(external_effect_namespaceObject.Schema.pattern(/^(\u2014|[~^]?\d+\.\d+\.\d+(?:[-+.][\w.+-]*)?)$/));
+const DependencyTableRowSchema = external_effect_namespaceObject.Schema.Struct({
+    dependency: NonEmptyString,
+    type: DependencyTableTypeSchema,
+    action: DependencyActionSchema,
+    from: VersionOrEmptySchema,
+    to: VersionOrEmptySchema
+});
+external_effect_namespaceObject.Schema.Array(DependencyTableRowSchema).pipe(external_effect_namespaceObject.Schema.minItems(1));
+const COLUMN_HEADERS = [
+    "Dependency",
+    "Type",
+    "Action",
+    "From",
+    "To"
+];
+const COLUMN_KEYS = [
+    "dependency",
+    "type",
+    "action",
+    "from",
+    "to"
+];
+const decode = external_effect_namespaceObject.Schema.decodeUnknownSync(DependencyTableRowSchema);
+function parseDependencyTable(table) {
+    const rows = table.children;
+    if (rows.length < 2) throw new Error("Dependency table must have at least one data row");
+    const headerRow = rows[0];
+    const headers = headerRow.children.map((cell)=>(0, external_mdast_util_to_string_namespaceObject.toString)(cell).trim().toLowerCase());
+    const expected = COLUMN_HEADERS.map((h)=>h.toLowerCase());
+    if (headers.length !== expected.length || !headers.every((h, i)=>h === expected[i])) throw new Error(`Table must have columns: ${COLUMN_HEADERS.join(", ")}. Got: ${headers.join(", ")}`);
+    const result = [];
+    for(let i = 1; i < rows.length; i++){
+        const cells = rows[i].children;
+        const raw = {};
+        for(let c = 0; c < COLUMN_KEYS.length; c++)raw[COLUMN_KEYS[c]] = (0, external_mdast_util_to_string_namespaceObject.toString)(cells[c]).trim();
+        result.push(decode(raw));
+    }
+    return result;
+}
+function makeCell(text) {
+    return {
+        type: "tableCell",
+        children: [
+            {
+                type: "text",
+                value: text
+            }
+        ]
+    };
+}
+function makeRow(texts) {
+    return {
+        type: "tableRow",
+        children: texts.map(makeCell)
+    };
+}
+function serializeDependencyTable(rows) {
+    const headerRow = makeRow([
+        ...COLUMN_HEADERS
+    ]);
+    const dataRows = rows.map((row)=>makeRow(COLUMN_KEYS.map((key)=>row[key])));
+    return {
+        type: "table",
+        children: [
+            headerRow,
+            ...dataRows
+        ]
+    };
+}
+const ACTION_ORDER = {
+    removed: 0,
+    updated: 1,
+    added: 2
+};
+function collapseDependencyRows(rows) {
+    const groups = new Map();
+    for (const row of rows){
+        const key = `${row.dependency}\0${row.type}`;
+        const existing = groups.get(key);
+        if (!existing) {
+            groups.set(key, {
+                ...row
+            });
+            continue;
+        }
+        const merged = collapseTwo(existing, row);
+        if (null === merged) groups.delete(key);
+        else groups.set(key, merged);
+    }
+    return [
+        ...groups.values()
+    ];
+}
+function collapseTwo(first, second) {
+    const a = first.action;
+    const b = second.action;
+    if ("updated" === a && "updated" === b) return {
+        ...first,
+        to: second.to
+    };
+    if ("added" === a && "updated" === b) return {
+        ...first,
+        to: second.to
+    };
+    if ("added" === a && "removed" === b) return null;
+    if ("updated" === a && "removed" === b) return {
+        ...first,
+        action: "removed",
+        to: "\u2014"
+    };
+    if ("removed" === a && "added" === b) return {
+        ...first,
+        action: "updated",
+        to: second.to
+    };
+    return {
+        ...second
+    };
+}
+function sortDependencyRows(rows) {
+    return [
+        ...rows
+    ].sort((a, b)=>{
+        const actionDiff = (ACTION_ORDER[a.action] ?? 99) - (ACTION_ORDER[b.action] ?? 99);
+        if (0 !== actionDiff) return actionDiff;
+        const typeDiff = a.type.localeCompare(b.type);
+        if (0 !== typeDiff) return typeDiff;
+        return a.dependency.localeCompare(b.dependency);
+    });
+}
 function getVersionBlocks(tree) {
     const blocks = [];
     for(let i = 0; i < tree.children.length; i++){
@@ -68,6 +208,49 @@ function getBlockSections(tree, block) {
 function getHeadingText(heading) {
     return (0, external_mdast_util_to_string_namespaceObject.toString)(heading);
 }
+const AggregateDependencyTablesPlugin = ()=>(tree)=>{
+        const blocks = getVersionBlocks(tree);
+        for(let b = blocks.length - 1; b >= 0; b--){
+            const sections = getBlockSections(tree, blocks[b]);
+            const depSections = sections.filter((s)=>"dependencies" === getHeadingText(s.heading).toLowerCase());
+            if (0 === depSections.length) continue;
+            const allRows = [];
+            const legacyContent = [];
+            for (const section of depSections)for (const node of section.contentNodes)if ("table" === node.type) try {
+                const rows = parseDependencyTable(node);
+                allRows.push(...rows);
+            } catch  {
+                legacyContent.push(node);
+            }
+            else legacyContent.push(node);
+            const collapsed = sortDependencyRows(collapseDependencyRows(allRows));
+            const indicesToRemove = [];
+            for (const section of depSections){
+                indicesToRemove.push(section.headingIndex);
+                for(let c = 0; c < section.contentNodes.length; c++)indicesToRemove.push(section.headingIndex + 1 + c);
+            }
+            indicesToRemove.sort((a, b)=>b - a);
+            for (const idx of indicesToRemove)tree.children.splice(idx, 1);
+            if (0 === collapsed.length && 0 === legacyContent.length) continue;
+            const insertAt = depSections[0].headingIndex;
+            const newNodes = [];
+            const heading = {
+                type: "heading",
+                depth: 3,
+                children: [
+                    {
+                        type: "text",
+                        value: "Dependencies"
+                    }
+                ]
+            };
+            newNodes.push(heading);
+            if (collapsed.length > 0) newNodes.push(serializeDependencyTable(collapsed));
+            newNodes.push(...legacyContent);
+            tree.children.splice(insertAt, 0, ...newNodes);
+        }
+    };
+const external_unist_util_visit_namespaceObject = require("unist-util-visit");
 const ATTRIBUTION_PLAIN_RE = /\s*Thanks @(\w[\w-]*)!$/;
 function extractLinkedAttribution(children) {
     if (children.length < 3) return;
@@ -479,7 +662,8 @@ const RULE_DOCS = {
     CSH001: `${DOCS_BASE}/CSH001.md`,
     CSH002: `${DOCS_BASE}/CSH002.md`,
     CSH003: `${DOCS_BASE}/CSH003.md`,
-    CSH004: `${DOCS_BASE}/CSH004.md`
+    CSH004: `${DOCS_BASE}/CSH004.md`,
+    CSH005: `${DOCS_BASE}/CSH005.md`
 };
 const ContentStructureRule = (0, external_unified_lint_rule_namespaceObject.lintRule)("remark-lint:changeset-content-structure", (tree, file)=>{
     (0, external_unist_util_visit_namespaceObject.visit)(tree, "heading", (node, index, parent)=>{
@@ -495,6 +679,32 @@ const ContentStructureRule = (0, external_unified_lint_rule_namespaceObject.lint
         if (!text) file.message(`Empty list item. Each list item must contain descriptive text (e.g., "- Fixed login timeout issue"). See: ${RULE_DOCS.CSH003}`, node);
     });
 });
+const EM_DASH = "\u2014";
+const DependencyTableFormatRule = (0, external_unified_lint_rule_namespaceObject.lintRule)("remark-lint:changeset-dependency-table-format", (tree, file)=>{
+    (0, external_unist_util_visit_namespaceObject.visit)(tree, "heading", (node, index)=>{
+        if (2 !== node.depth) return;
+        if ("dependencies" !== (0, external_mdast_util_to_string_namespaceObject.toString)(node).toLowerCase()) return;
+        if (void 0 === index) return;
+        const content = [];
+        for(let i = index + 1; i < tree.children.length; i++){
+            const child = tree.children[i];
+            if ("heading" === child.type) break;
+            content.push(child);
+        }
+        const tables = content.filter((n)=>"table" === n.type);
+        if (0 === tables.length) return void file.message(`Dependencies section must contain a table, not a list or paragraph. See: ${RULE_DOCS.CSH005}`, node);
+        const table = tables[0];
+        try {
+            const rows = parseDependencyTable(table);
+            for (const row of rows){
+                if ("added" === row.action && row.from !== EM_DASH) file.message(`'from' must be '\u2014' when action is 'added' (got '${row.from}'). See: ${RULE_DOCS.CSH005}`, table);
+                if ("removed" === row.action && row.to !== EM_DASH) file.message(`'to' must be '\u2014' when action is 'removed' (got '${row.to}'). See: ${RULE_DOCS.CSH005}`, table);
+            }
+        } catch (error) {
+            file.message(`${error instanceof Error ? error.message : String(error)}. See: ${RULE_DOCS.CSH005}`, table);
+        }
+    });
+});
 const HeadingHierarchyRule = (0, external_unified_lint_rule_namespaceObject.lintRule)("remark-lint:changeset-heading-hierarchy", (tree, file)=>{
     let prevDepth = 0;
     (0, external_unist_util_visit_namespaceObject.visit)(tree, "heading", (node)=>{
@@ -527,9 +737,11 @@ const SilkChangesetPreset = [
     HeadingHierarchyRule,
     RequiredSectionsRule,
     ContentStructureRule,
-    UncategorizedContentRule
+    UncategorizedContentRule,
+    DependencyTableFormatRule
 ];
 const SilkChangesetTransformPreset = [
+    AggregateDependencyTablesPlugin,
     MergeSectionsPlugin,
     ReorderSectionsPlugin,
     DeduplicateItemsPlugin,
@@ -537,9 +749,11 @@ const SilkChangesetTransformPreset = [
     IssueLinkRefsPlugin,
     NormalizeFormatPlugin
 ];
+exports.AggregateDependencyTablesPlugin = __webpack_exports__.AggregateDependencyTablesPlugin;
 exports.ContentStructureRule = __webpack_exports__.ContentStructureRule;
 exports.ContributorFootnotesPlugin = __webpack_exports__.ContributorFootnotesPlugin;
 exports.DeduplicateItemsPlugin = __webpack_exports__.DeduplicateItemsPlugin;
+exports.DependencyTableFormatRule = __webpack_exports__.DependencyTableFormatRule;
 exports.HeadingHierarchyRule = __webpack_exports__.HeadingHierarchyRule;
 exports.IssueLinkRefsPlugin = __webpack_exports__.IssueLinkRefsPlugin;
 exports.MergeSectionsPlugin = __webpack_exports__.MergeSectionsPlugin;
@@ -550,9 +764,11 @@ exports.SilkChangesetPreset = __webpack_exports__.SilkChangesetPreset;
 exports.SilkChangesetTransformPreset = __webpack_exports__.SilkChangesetTransformPreset;
 exports.UncategorizedContentRule = __webpack_exports__.UncategorizedContentRule;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AggregateDependencyTablesPlugin",
     "ContentStructureRule",
     "ContributorFootnotesPlugin",
     "DeduplicateItemsPlugin",
+    "DependencyTableFormatRule",
     "HeadingHierarchyRule",
     "IssueLinkRefsPlugin",
     "MergeSectionsPlugin",