@savvy-web/silk-effects 0.6.1 → 1.0.0

package/changesets/remark/plugins/normalize-format.js

@@ -0,0 +1,47 @@
+import { getVersionBlocks } from "../../utils/version-blocks.js";
+import { toString } from "mdast-util-to-string";
+
+//#region src/changesets/remark/plugins/normalize-format.ts
+/**
+* Check if a node is a heading at one of the given depths.
+*
+* @param node - The AST node to check
+* @param depths - Allowed heading depths
+* @returns `true` if the node is a heading at one of the specified depths
+*
+* @internal
+*/
+function isHeadingAtDepth(node, depths) {
+	return node.type === "heading" && depths.includes(node.depth);
+}
+const NormalizeFormatPlugin = () => {
+	return (tree) => {
+		const blocks = getVersionBlocks(tree);
+		const indicesToRemove = /* @__PURE__ */ new Set();
+		for (const block of blocks) for (let i = block.startIndex; i < block.endIndex; i++) {
+			const node = tree.children[i];
+			if (node.type === "list" && node.children.length === 0) {
+				indicesToRemove.add(i);
+				continue;
+			}
+			if (!isHeadingAtDepth(node, [3])) continue;
+			let hasContent = false;
+			for (let j = i + 1; j < block.endIndex; j++) {
+				const next = tree.children[j];
+				if (next.type === "paragraph" && toString(next).trim() === "") {
+					indicesToRemove.add(j);
+					continue;
+				}
+				if (isHeadingAtDepth(next, [2, 3])) break;
+				hasContent = true;
+				break;
+			}
+			if (!hasContent) indicesToRemove.add(i);
+		}
+		const sorted = [...indicesToRemove].sort((a, b) => b - a);
+		for (const idx of sorted) tree.children.splice(idx, 1);
+	};
+};
+
+//#endregion
+export { NormalizeFormatPlugin };

package/changesets/remark/plugins/reorder-sections.js

@@ -0,0 +1,34 @@
+import { fromHeading } from "../../categories/index.js";
+import { getBlockSections, getHeadingText, getVersionBlocks } from "../../utils/version-blocks.js";
+
+//#region src/changesets/remark/plugins/reorder-sections.ts
+/**
+* Default priority for unrecognized headings (sorts after all known categories).
+*
+* @internal
+*/
+const UNKNOWN_PRIORITY = 999;
+const ReorderSectionsPlugin = () => {
+	return (tree) => {
+		const blocks = getVersionBlocks(tree);
+		for (let b = blocks.length - 1; b >= 0; b--) {
+			const block = blocks[b];
+			const sections = getBlockSections(tree, block);
+			if (sections.length <= 1) continue;
+			const preamble = [];
+			for (let i = block.startIndex; i < block.endIndex; i++) if (i < sections[0].headingIndex) preamble.push(tree.children[i]);
+			else break;
+			const sorted = [...sections].sort((a, b) => {
+				return (fromHeading(getHeadingText(a.heading))?.priority ?? UNKNOWN_PRIORITY) - (fromHeading(getHeadingText(b.heading))?.priority ?? UNKNOWN_PRIORITY);
+			});
+			if (sorted.every((s, i) => s.headingIndex === sections[i].headingIndex)) continue;
+			const newChildren = [...preamble];
+			for (const section of sorted) newChildren.push(section.heading, ...section.contentNodes);
+			const blockLength = block.endIndex - block.startIndex;
+			tree.children.splice(block.startIndex, blockLength, ...newChildren);
+		}
+	};
+};
+
+//#endregion
+export { ReorderSectionsPlugin };

package/changesets/remark/presets.js

@@ -0,0 +1,119 @@
+import { ContentStructureRule } from "./rules/content-structure.js";
+import { HeadingHierarchyRule } from "./rules/heading-hierarchy.js";
+import { RequiredSectionsRule } from "./rules/required-sections.js";
+import { UncategorizedContentRule } from "./rules/uncategorized-content.js";
+import { ContributorFootnotesPlugin } from "./plugins/contributor-footnotes.js";
+import { DeduplicateItemsPlugin } from "./plugins/deduplicate-items.js";
+import { IssueLinkRefsPlugin } from "./plugins/issue-link-refs.js";
+import { MergeSectionsPlugin } from "./plugins/merge-sections.js";
+import { NormalizeFormatPlugin } from "./plugins/normalize-format.js";
+import { ReorderSectionsPlugin } from "./plugins/reorder-sections.js";
+import { AggregateDependencyTablesPlugin } from "./plugins/aggregate-dependency-tables.js";
+import { DependencyTableFormatRule } from "./rules/dependency-table-format.js";
+
+//#region src/changesets/remark/presets.ts
+/**
+* Remark preset collections for changeset lint rules and transform plugins.
+*
+* @remarks
+* Presets bundle related remark plugins into ordered arrays for convenient
+* consumption. Each preset is a `readonly` tuple so that TypeScript can
+* narrow element types. Iterate and `.use()` each entry with `unified()`.
+*
+* @see {@link SilkChangesetPreset} for lint rules
+* @see {@link SilkChangesetTransformPreset} for transform plugins
+*/
+/**
+* Preset combining all changeset lint rules for convenient consumption.
+*
+* @remarks
+* Includes the following rules in order:
+*
+* 1. {@link HeadingHierarchyRule} (CSH001) -- no h1, no depth skips
+* 2. {@link RequiredSectionsRule} (CSH002) -- h2 headings must match a known category
+* 3. {@link ContentStructureRule} (CSH003) -- non-empty sections, code fence languages, non-empty list items
+* 4. {@link UncategorizedContentRule} (CSH004) -- no content before the first h2 heading
+* 5. {@link DependencyTableFormatRule} (CSH005) -- dependency table column/value validation
+*
+* Rule execution order is not significant for lint rules; all rules run
+* independently over the same AST and report warnings to the virtual file.
+*
+* @example
+* ```typescript
+* import { SilkChangesetPreset } from "\@savvy-web/changesets/remark";
+* import remarkParse from "remark-parse";
+* import { unified } from "unified";
+* import { read } from "to-vfile";
+*
+* const processor = unified().use(remarkParse);
+* for (const rule of SilkChangesetPreset) {
+*   processor.use(rule);
+* }
+*
+* const file = await read("changeset.md");
+* const result = await processor.process(file);
+* console.log(result.messages); // lint warnings
+* ```
+*
+* @see {@link SilkChangesetTransformPreset} for the corresponding transform preset
+*
+* @public
+*/
+const SilkChangesetPreset = [
+	HeadingHierarchyRule,
+	RequiredSectionsRule,
+	ContentStructureRule,
+	UncategorizedContentRule,
+	DependencyTableFormatRule
+];
+/**
+* Ordered array of all transform plugins in the correct execution order.
+*
+* @remarks
+* Plugin ordering is significant -- each plugin may depend on the output of
+* earlier plugins in the pipeline:
+*
+* 1. {@link AggregateDependencyTablesPlugin} -- merge duplicate dependency sections (must run first so downstream plugins see a single Dependencies section)
+* 2. {@link MergeSectionsPlugin} -- merge duplicate h3 headings (must run before reorder so that priority is computed on consolidated sections)
+* 3. {@link ReorderSectionsPlugin} -- sort sections by category priority (Breaking Changes first, Other last)
+* 4. {@link DeduplicateItemsPlugin} -- remove duplicate list items within each section
+* 5. {@link ContributorFootnotesPlugin} -- extract inline `Thanks \@user!` attributions and aggregate them into a summary paragraph per version block
+* 6. {@link IssueLinkRefsPlugin} -- convert inline `[#N](url)` links to reference-style `[#N]` with definitions at the end of each version block
+* 7. {@link NormalizeFormatPlugin} -- final cleanup removing empty sections and empty lists
+*
+* @example
+* ```typescript
+* import { SilkChangesetTransformPreset } from "\@savvy-web/changesets/remark";
+* import remarkGfm from "remark-gfm";
+* import remarkParse from "remark-parse";
+* import remarkStringify from "remark-stringify";
+* import { unified } from "unified";
+* import { read } from "to-vfile";
+*
+* const processor = unified().use(remarkParse).use(remarkGfm);
+* for (const plugin of SilkChangesetTransformPreset) {
+*   processor.use(plugin);
+* }
+* processor.use(remarkStringify);
+*
+* const file = await read("CHANGELOG.md");
+* const result = await processor.process(file);
+* console.log(String(result));
+* ```
+*
+* @see {@link SilkChangesetPreset} for the corresponding lint preset
+*
+* @public
+*/
+const SilkChangesetTransformPreset = [
+	AggregateDependencyTablesPlugin,
+	MergeSectionsPlugin,
+	ReorderSectionsPlugin,
+	DeduplicateItemsPlugin,
+	ContributorFootnotesPlugin,
+	IssueLinkRefsPlugin,
+	NormalizeFormatPlugin
+];
+
+//#endregion
+export { SilkChangesetPreset, SilkChangesetTransformPreset };

package/changesets/remark/rules/content-structure.js

@@ -0,0 +1,22 @@
+import { RULE_DOCS } from "../../constants.js";
+import { toString } from "mdast-util-to-string";
+import { lintRule } from "unified-lint-rule";
+import { visit } from "unist-util-visit";
+
+//#region src/changesets/remark/rules/content-structure.ts
+const ContentStructureRule = lintRule("remark-lint:changeset-content-structure", (tree, file) => {
+	visit(tree, "heading", (node, index, parent) => {
+		if (node.depth !== 2 || parent == null || index == null) return;
+		const next = parent.children[index + 1];
+		if (!next || next.type === "heading" && next.depth === 2) file.message(`Empty section: heading has no content before the next section or end of file. Add a list of changes (e.g., "- Added feature X") under this heading, or remove the empty heading. See: ${RULE_DOCS.CSH003}`, node);
+	});
+	visit(tree, "code", (node) => {
+		if (!node.lang) file.message(`Code block is missing a language identifier. Add a language after the opening fence (e.g., \`\`\`ts, \`\`\`json, \`\`\`bash). See: ${RULE_DOCS.CSH003}`, node);
+	});
+	visit(tree, "listItem", (node) => {
+		if (!toString(node).trim()) file.message(`Empty list item. Each list item must contain descriptive text (e.g., "- Fixed login timeout issue"). See: ${RULE_DOCS.CSH003}`, node);
+	});
+});
+
+//#endregion
+export { ContentStructureRule };

package/changesets/remark/rules/dependency-table-format.js

@@ -0,0 +1,40 @@
+import { parseDependencyTable } from "../../utils/dependency-table.js";
+import { RULE_DOCS } from "../../constants.js";
+import { toString } from "mdast-util-to-string";
+import { lintRule } from "unified-lint-rule";
+import { visit } from "unist-util-visit";
+
+//#region src/changesets/remark/rules/dependency-table-format.ts
+/** @internal */
+const EM_DASH = "—";
+const DependencyTableFormatRule = lintRule("remark-lint:changeset-dependency-table-format", (tree, file) => {
+	visit(tree, "heading", (node, index) => {
+		if (node.depth !== 2) return;
+		if (toString(node).toLowerCase() !== "dependencies") return;
+		if (index === void 0) return;
+		const content = [];
+		for (let i = index + 1; i < tree.children.length; i++) {
+			const child = tree.children[i];
+			if (child.type === "heading") break;
+			content.push(child);
+		}
+		const tables = content.filter((n) => n.type === "table");
+		if (tables.length === 0) {
+			file.message(`Dependencies section must contain a table, not a list or paragraph. See: ${RULE_DOCS.CSH005}`, node);
+			return;
+		}
+		const table = tables[0];
+		try {
+			const rows = parseDependencyTable(table);
+			for (const row of rows) {
+				if (row.action === "added" && row.from !== EM_DASH) file.message(`'from' must be '\u2014' when action is 'added' (got '${row.from}'). See: ${RULE_DOCS.CSH005}`, table);
+				if (row.action === "removed" && 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);
+		}
+	});
+});
+
+//#endregion
+export { DependencyTableFormatRule };

package/changesets/remark/rules/heading-hierarchy.js

@@ -0,0 +1,19 @@
+import { RULE_DOCS } from "../../constants.js";
+import { lintRule } from "unified-lint-rule";
+import { visit } from "unist-util-visit";
+
+//#region src/changesets/remark/rules/heading-hierarchy.ts
+const HeadingHierarchyRule = lintRule("remark-lint:changeset-heading-hierarchy", (tree, file) => {
+	let prevDepth = 0;
+	visit(tree, "heading", (node) => {
+		if (node.depth === 1) {
+			file.message(`h1 headings are not allowed in changeset files. Use h2 (##) for top-level sections like "## Features" or "## Bug Fixes". h1 is reserved for the version title generated by the changelog formatter. See: ${RULE_DOCS.CSH001}`, node);
+			return;
+		}
+		if (prevDepth > 0 && node.depth > prevDepth + 1) file.message(`Heading level skipped: expected h${prevDepth + 1} or lower, found h${node.depth}. Headings must increase sequentially (h2 → h3 → h4). Add the missing intermediate level or reduce this heading's depth. See: ${RULE_DOCS.CSH001}`, node);
+		prevDepth = node.depth;
+	});
+});
+
+//#endregion
+export { HeadingHierarchyRule };

package/changesets/remark/rules/required-sections.js

@@ -0,0 +1,17 @@
+import { allHeadings, isValidHeading } from "../../categories/index.js";
+import { RULE_DOCS } from "../../constants.js";
+import { toString } from "mdast-util-to-string";
+import { lintRule } from "unified-lint-rule";
+import { visit } from "unist-util-visit";
+
+//#region src/changesets/remark/rules/required-sections.ts
+const RequiredSectionsRule = lintRule("remark-lint:changeset-required-sections", (tree, file) => {
+	visit(tree, "heading", (node) => {
+		if (node.depth !== 2) return;
+		const text = toString(node);
+		if (!isValidHeading(text)) file.message(`Unknown section "${text}". Valid h2 headings are: ${allHeadings().join(", ")}. Heading comparison is case-insensitive. See: ${RULE_DOCS.CSH002}`, node);
+	});
+});
+
+//#endregion
+export { RequiredSectionsRule };

package/changesets/remark/rules/uncategorized-content.js

@@ -0,0 +1,31 @@
+import { RULE_DOCS } from "../../constants.js";
+import { lintRule } from "unified-lint-rule";
+
+//#region src/changesets/remark/rules/uncategorized-content.ts
+/**
+* Node types to ignore when detecting uncategorized content (e.g., HTML comments).
+*
+* @internal
+*/
+const IGNORED_TYPES = new Set(["html"]);
+/**
+* Determine whether a node is substantive content (not a heading or ignored type).
+*
+* @param node - The AST node to check
+* @returns `true` if the node is content that should be under a heading
+*
+* @internal
+*/
+function isContentNode(node) {
+	if (node.type === "heading") return false;
+	return !IGNORED_TYPES.has(node.type);
+}
+const UncategorizedContentRule = lintRule("remark-lint:changeset-uncategorized-content", (tree, file) => {
+	for (const node of tree.children) {
+		if (node.type === "heading" && node.depth === 2) break;
+		if (isContentNode(node)) file.message(`Content must be placed under a category heading (## heading). Move this content under an appropriate section like "## Features" or "## Bug Fixes". If it doesn't fit an existing category, use "## Other". See: ${RULE_DOCS.CSH004}`, node);
+	}
+});
+
+//#endregion
+export { UncategorizedContentRule };

package/changesets/schemas/changeset.js

@@ -0,0 +1,146 @@
+import { NonEmptyString } from "./primitives.js";
+import { CommitHashSchema } from "./git.js";
+import { Schema } from "effect";
+
+//#region src/changesets/schemas/changeset.ts
+/**
+* Effect schemas for changeset entries and dependency updates.
+*
+* @remarks
+* These schemas define the canonical representation of changeset data
+* consumed by the changelog formatter (Layer 2) and validated by the
+* remark-lint pre-validation layer (Layer 1). They enforce constraints
+* such as summary length limits and valid dependency types at system
+* boundaries.
+*
+* @see {@link https://github.com/changesets/changesets | Changesets documentation}
+* @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
+*
+* @packageDocumentation
+*/
+/**
+* Schema for a changeset summary (1--1000 characters).
+*
+* @remarks
+* Enforces that every changeset has a non-empty summary and caps length
+* at 1000 characters. Longer descriptions should go in the changeset body,
+* not the summary line. Validation messages guide users toward correct usage.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { ChangesetSummarySchema } from "@savvy-web/changesets";
+*
+* // Succeeds — valid summary
+* const summary = Schema.decodeUnknownSync(ChangesetSummarySchema)(
+* 	"Fix authentication timeout in login flow"
+* );
+*
+* // Throws ParseError — empty string
+* Schema.decodeUnknownSync(ChangesetSummarySchema)("");
+* ```
+*
+* @public
+*/
+const ChangesetSummarySchema = Schema.String.pipe(Schema.minLength(1, { message: () => "Changeset summary cannot be empty. Provide a 1-1000 character description of the change (e.g., \"Fix authentication timeout in login flow\")" }), Schema.maxLength(1e3, { message: () => "Changeset summary exceeds the 1000 character limit. Shorten the summary to at most 1000 characters — use the changeset body for additional details" }));
+/**
+* Schema for a changeset object.
+*
+* @remarks
+* Represents a single changeset entry as consumed by the changelog formatter.
+* The `summary` is the human-readable description, `id` is a unique identifier
+* (typically the changeset filename without extension), and `commit` is the
+* optional git SHA that introduced the changeset.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { ChangesetSchema } from "@savvy-web/changesets";
+* import type { Changeset } from "@savvy-web/changesets";
+*
+* const changeset: Changeset = Schema.decodeUnknownSync(ChangesetSchema)({
+* 	summary: "Add retry logic to API client",
+* 	id: "brave-dogs-laugh",
+* 	commit: "a1b2c3d",
+* });
+* ```
+*
+* @see {@link Changeset} for the inferred TypeScript type
+* @see {@link ChangesetSummarySchema} for summary validation rules
+* @see {@link CommitHashSchema} for commit hash format requirements
+*
+* @public
+*/
+const ChangesetSchema = Schema.Struct({
+	/** The changeset summary text. */
+	summary: ChangesetSummarySchema,
+	/** Unique changeset identifier. */
+	id: Schema.String,
+	/** Git commit hash associated with this changeset. */
+	commit: Schema.optional(CommitHashSchema)
+});
+/**
+* Schema for npm dependency types.
+*
+* @remarks
+* Represents the four standard `package.json` dependency fields using their
+* plural key names as they appear in the manifest. For the singular,
+* table-oriented variant that includes `workspace` and `config` types,
+* see {@link DependencyTableTypeSchema}.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { DependencyTypeSchema } from "@savvy-web/changesets";
+* import type { DependencyType } from "@savvy-web/changesets";
+*
+* const depType: DependencyType = Schema.decodeUnknownSync(DependencyTypeSchema)(
+* 	"devDependencies"
+* );
+* ```
+*
+* @see {@link DependencyTableTypeSchema} for the extended singular-form variant
+*
+* @public
+*/
+const DependencyTypeSchema = Schema.Literal("dependencies", "devDependencies", "peerDependencies", "optionalDependencies");
+/**
+* Schema for a dependency update entry.
+*
+* @remarks
+* Represents a single dependency version change as reported by
+* the Changesets API. Captures the package name, which dependency
+* field it belongs to, and the old and new version strings.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { DependencyUpdateSchema } from "@savvy-web/changesets";
+* import type { DependencyUpdate } from "@savvy-web/changesets";
+*
+* const update: DependencyUpdate = Schema.decodeUnknownSync(DependencyUpdateSchema)({
+* 	name: "effect",
+* 	type: "dependencies",
+* 	oldVersion: "3.18.0",
+* 	newVersion: "3.19.1",
+* });
+* ```
+*
+* @see {@link DependencyUpdate} for the inferred TypeScript type
+* @see {@link DependencyTableRowSchema} for the table-formatted variant
+*
+* @public
+*/
+const DependencyUpdateSchema = Schema.Struct({
+	/** Package name (must be non-empty). */
+	name: NonEmptyString.annotations({ message: () => "Package name cannot be empty" }),
+	/** npm dependency type. */
+	type: DependencyTypeSchema,
+	/** Previous version string. */
+	oldVersion: Schema.String,
+	/** New version string. */
+	newVersion: Schema.String
+});
+
+//#endregion
+export { ChangesetSchema, ChangesetSummarySchema, DependencyTypeSchema, DependencyUpdateSchema };

package/changesets/schemas/dependency-table.js

@@ -0,0 +1,189 @@
+import { NonEmptyString } from "./primitives.js";
+import { Schema } from "effect";
+
+//#region src/changesets/schemas/dependency-table.ts
+/**
+* Effect schemas for structured dependency table entries.
+*
+* @remarks
+* These schemas define the canonical representation for dependency
+* changes tracked as markdown tables in changeset files and CHANGELOGs.
+* The table format provides a richer view than {@link DependencyUpdateSchema}
+* by supporting singular dependency type names, workspace/config types,
+* and explicit add/update/remove actions.
+*
+* A dependency table row looks like this in a CHANGELOG:
+*
+* | Dependency | Type | Action | From | To |
+* |---|---|---|---|---|
+* | effect | dependency | updated | 3.18.0 | 3.19.1 |
+*
+* @see {@link DependencyUpdateSchema} for the simpler Changesets API format
+* @see {@link https://effect.website/docs/schema/introduction | Effect Schema documentation}
+*
+* @packageDocumentation
+*/
+/**
+* Valid dependency table actions.
+*
+* @remarks
+* Represents the three possible operations on a dependency: `"added"` for
+* new dependencies, `"updated"` for version changes, and `"removed"` for
+* deletions. Used in the "Action" column of dependency tables.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { DependencyActionSchema } from "@savvy-web/changesets";
+* import type { DependencyAction } from "@savvy-web/changesets";
+*
+* const action: DependencyAction = Schema.decodeUnknownSync(DependencyActionSchema)("updated");
+* ```
+*
+* @public
+*/
+const DependencyActionSchema = Schema.Literal("added", "updated", "removed");
+/**
+* Extended dependency types for table format.
+*
+* @remarks
+* Unlike {@link DependencyTypeSchema} (which uses plural npm field names like
+* `"dependencies"`), this schema uses singular forms (`"dependency"`) and adds
+* two additional types: `"workspace"` for monorepo workspace references and
+* `"config"` for configuration toolchain updates (e.g., ESLint, TypeScript).
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { DependencyTableTypeSchema } from "@savvy-web/changesets";
+* import type { DependencyTableType } from "@savvy-web/changesets";
+*
+* const tableType: DependencyTableType = Schema.decodeUnknownSync(
+* 	DependencyTableTypeSchema
+* )("workspace");
+* ```
+*
+* @see {@link DependencyTypeSchema} for the plural npm-field variant
+*
+* @public
+*/
+const DependencyTableTypeSchema = Schema.Literal("dependency", "devDependency", "peerDependency", "optionalDependency", "workspace", "config");
+/**
+* Version string or em dash (U+2014) sentinel for added/removed entries.
+*
+* @remarks
+* Accepts either a semver-like version string (with optional `~` or `^`
+* prefix and pre-release/build suffixes) or the em dash character `\u2014`
+* which serves as a sentinel: the "From" column uses `\u2014` for newly
+* added dependencies, and the "To" column uses it for removed ones.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { VersionOrEmptySchema } from "@savvy-web/changesets";
+*
+* // Succeeds — semver version
+* Schema.decodeUnknownSync(VersionOrEmptySchema)("^3.19.1");
+*
+* // Succeeds — em dash sentinel for "no version"
+* Schema.decodeUnknownSync(VersionOrEmptySchema)("\u2014");
+*
+* // Throws ParseError — arbitrary text
+* Schema.decodeUnknownSync(VersionOrEmptySchema)("latest");
+* ```
+*
+* @public
+*/
+const VersionOrEmptySchema = Schema.String.pipe(Schema.pattern(/^(\u2014|[~^]?\d+\.\d+\.\d+(?:[-+.][\w.+-]*)?)$/));
+/**
+* Schema for a single dependency table row.
+*
+* @remarks
+* Represents one row of a dependency update table in a CHANGELOG.
+* Each row captures the dependency name, its type, the change action,
+* and the "from" and "to" version strings. For added dependencies the
+* `from` field is an em dash; for removed dependencies the `to` field
+* is an em dash.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { DependencyTableRowSchema } from "@savvy-web/changesets";
+* import type { DependencyTableRow } from "@savvy-web/changesets";
+*
+* const row: DependencyTableRow = Schema.decodeUnknownSync(DependencyTableRowSchema)({
+* 	dependency: "effect",
+* 	type: "dependency",
+* 	action: "updated",
+* 	from: "3.18.0",
+* 	to: "3.19.1",
+* });
+*
+* // Newly added dependency — "from" is em dash
+* const addedRow: DependencyTableRow = Schema.decodeUnknownSync(DependencyTableRowSchema)({
+* 	dependency: "@effect/cli",
+* 	type: "dependency",
+* 	action: "added",
+* 	from: "\u2014",
+* 	to: "0.50.0",
+* });
+* ```
+*
+* @see {@link DependencyTableRow} for the inferred TypeScript type
+* @see {@link DependencyTableSchema} for a non-empty array of rows
+*
+* @public
+*/
+const DependencyTableRowSchema = Schema.Struct({
+	/** Package or toolchain name. */
+	dependency: NonEmptyString,
+	/** Dependency type. */
+	type: DependencyTableTypeSchema,
+	/** Change action. */
+	action: DependencyActionSchema,
+	/** Previous version (em dash for added). */
+	from: VersionOrEmptySchema,
+	/** New version (em dash for removed). */
+	to: VersionOrEmptySchema
+});
+/**
+* Schema for a dependency table (non-empty array of rows).
+*
+* @remarks
+* Validates that the table contains at least one row. Used to represent
+* the full dependency update table in a changeset or CHANGELOG entry.
+*
+* @example
+* ```typescript
+* import { Schema } from "effect";
+* import { DependencyTableSchema } from "@savvy-web/changesets";
+*
+* const table = Schema.decodeUnknownSync(DependencyTableSchema)([
+* 	{
+* 		dependency: "effect",
+* 		type: "dependency",
+* 		action: "updated",
+* 		from: "3.18.0",
+* 		to: "3.19.1",
+* 	},
+* 	{
+* 		dependency: "typescript",
+* 		type: "config",
+* 		action: "updated",
+* 		from: "5.6.0",
+* 		to: "5.7.2",
+* 	},
+* ]);
+*
+* // Throws ParseError — empty array
+* Schema.decodeUnknownSync(DependencyTableSchema)([]);
+* ```
+*
+* @see {@link DependencyTableRowSchema} for the individual row schema
+*
+* @public
+*/
+const DependencyTableSchema = Schema.Array(DependencyTableRowSchema).pipe(Schema.minItems(1));
+
+//#endregion
+export { DependencyActionSchema, DependencyTableRowSchema, DependencyTableSchema, DependencyTableTypeSchema, VersionOrEmptySchema };