@savvy-web/silk 3.15.3 → 4.0.0

package/changesets-markdownlint.js

@@ -1,9 +1,9 @@
 import { builtinModules, createRequire } from "node:module";
-import { CommentStyle, SectionId } from "@effected/templates";
 import { Context, Data, Effect, FileSystem, Layer, Option, Path, Result, Schema, SchemaIssue, SchemaTransformation } from "effect";
+import { CommentStyle, SectionId } from "@effected/templates";
+import { PublishTarget, PublishabilityDetector, WorkspaceDiscovery, WorkspaceSnapshots, WorkspaceStateSnapshot, Workspaces } from "@effected/workspaces";
 import * as path$1 from "node:path";
 import { basename, delimiter, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
-import { PublishTarget, PublishabilityDetector, WorkspaceDiscovery, WorkspaceSnapshots, WorkspaceStateSnapshot, Workspaces } from "@effected/workspaces";
 import * as fs$1 from "node:fs/promises";
 import * as util from "node:util";
 import { format, inspect, styleText } from "node:util";
@@ -75,7 +75,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __require$1 = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 
 //#endregion
-//#region ../silk-effects/dist/dev/pkg/errors/ChangesetConfigError.js
+//#region ../silk-core/dist/dev/pkg/errors/ChangesetConfigError.js
 /**
 * Raised when the `.changeset/config.json` file cannot be read or decoded.
 *
@@ -93,7 +93,451 @@ var ChangesetConfigError = class extends Data.TaggedError("ChangesetConfigError"
 };
 
 //#endregion
-//#region ../silk-effects/dist/dev/pkg/schemas/VersioningSchemas.js
+//#region ../silk-core/dist/dev/pkg/errors/PublishTargetBindingError.js
+/**
+* Raised when publishability detection selects a directory that the package's
+* `dist/prod/targets.json` binding does not describe.
+*
+* @remarks
+* The bundler's prod build writes `targets.json` naming every byte-group
+* directory it produced. Once that binding exists it is authoritative: the only
+* directories whose bytes may be published are the ones it lists. A detector
+* that returns anything else — most often `publishConfig.directory` pointing at
+* a **dev** build, because silk mode was misdetected — is about to pack an
+* unresolved workspace manifest and ship it to a registry.
+*
+* That is the `yaml-effect@0.7.1` failure: detection picked `dist/dev/pkg`, the
+* dev manifest still carried `catalog:` specifiers, and the published package
+* was uninstallable (`EUNSUPPORTEDPROTOCOL`).
+*
+* @since 3.1.0
+* @public
+*/
+var PublishTargetBindingError = class extends Data.TaggedError("PublishTargetBindingError") {
+	get message() {
+		return `Package ${this.pkg} resolved publish directory "${this.directory}", which is not one of the directories bound by dist/prod/targets.json (${this.boundDirectories.join(", ")}). This means publishability detection did not select the prod build output — refusing to publish before packing an unresolved manifest.`;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@effected+github-references@0.3.0_effect@4.0.0-rc.115/node_modules/@effected/github-references/IssueReferences.js
+/**
+* GitHub's closing-keyword issue-reference grammar, as pure functions.
+*
+* @remarks
+* GitHub links an issue to a pull request when the PR's description carries
+* `<keyword> #<number>` for one of nine documented keywords. Consumers speak
+* that grammar in two distinct dialects, and this module models exactly those
+* two — no service, no layer, nothing but strings in and values out:
+*
+* - **Inline-in-prose** ({@link harvestIssueReferences}): a reference may appear anywhere in
+*   running text — `"fixes #12 and closes #13"` — with mandatory whitespace
+*   and **no colon**, because that is the spelling GitHub itself scans PR
+*   bodies for. This is the dialect a release pipeline harvests from commit
+*   subjects and PR descriptions.
+* - **Bare-line** ({@link parseBareLineReference}): the whole line, after trimming, *is*
+*   the reference — `"Closes: #12"` — with an **optional colon**, because a
+*   generated references region writes one reference per line and a colon
+*   reads better there. GitHub does not require the colon; the region format
+*   allows it, so the parser must too. The dialects differ because their
+*   producers do: prose is written by humans for GitHub's scanner, the region
+*   is written by tooling for humans.
+*
+* Deliberately out of scope this round: cross-repo references
+* (`owner/repo#N`) and full-URL references
+* (`https://github.com/owner/repo/issues/N`). Both are real GitHub spellings;
+* neither dialect's consumers emit them yet, and guessing at their shape here
+* would freeze an API nobody has driven.
+*/
+/**
+* The nine closing keywords GitHub documents, lowercased.
+*
+* @public
+*/
+const CLOSING_KEYWORDS = [
+	"close",
+	"closes",
+	"closed",
+	"fix",
+	"fixes",
+	"fixed",
+	"resolve",
+	"resolves",
+	"resolved"
+];
+/**
+* Both patterns derive from {@link CLOSING_KEYWORDS} so the constant and the
+* grammar cannot drift. Alternation order is safe: the regex engine backtracks
+* through alternatives, so `close` matching inside `closes` fails at the
+* mandatory `#`-introducer and retries the longer keyword.
+*/
+const KEYWORDS = CLOSING_KEYWORDS.join("|");
+/** Inline-in-prose: mandatory whitespace, no colon. */
+const INLINE_PATTERN = new RegExp(`\\b(${KEYWORDS})\\s+#(\\d+)`, "gi");
+/**
+* Bare-line: optional colon, then mandatory same-line whitespace. `[ \t]`
+* rather than `\s`, so an embedded newline cannot smuggle two lines past a
+* parser whose contract is one.
+*/
+const BARE_LINE_PATTERN = new RegExp(`^(${KEYWORDS}):?[ \\t]+#(\\d+)$`, "i");
+
+//#endregion
+//#region ../../node_modules/.pnpm/@effected+github-references@0.3.0_effect@4.0.0-rc.115/node_modules/@effected/github-references/ClosingList.js
+/**
+* The closing-list dialect: one whole line naming several issues at once.
+*
+* @remarks
+* The third dialect, alongside the two in `IssueReferences`: after trimming,
+* the **entire** line must be `<keyword>[:] <list>` — keyword
+* case-insensitive (lowercased to canonical form in the result), colon
+* optional, and the list one or more `#<digits>` items separated by `,`,
+* `and`, or the Oxford `, and`. Whitespace inside the line is `[ \t]` only,
+* so an embedded newline cannot smuggle two lines past a parser whose
+* contract is one — the same posture as the bare-line pattern. Any trailing
+* content after the list rejects the line; duplicates are preserved in order,
+* because whether `#1, #1` means one issue or two is the caller's business.
+*
+* Two keyword sets play here. {@link parseClosingList} accepts only the nine
+* closing keywords and yields a {@link ClosingList}; {@link parseReferenceList}
+* additionally accepts the non-closing {@link REFERENCE_KEYWORDS} (`ref`,
+* `refs`, `references`) and reports which set matched via
+* {@link ReferenceList}'s `closing` flag.
+*
+* An item whose digits exceed `Number.MAX_SAFE_INTEGER` rejects the **whole
+* line**, where `harvestIssueReferences` merely skips the one match. The
+* asymmetry is deliberate: a harvest drops one reference out of running
+* prose, but a list line is a single claim about a set of issues, and
+* returning the parseable subset would misrepresent the line as claiming
+* less than it does.
+*
+* Complexity posture: parsing is a single left-to-right character scan —
+* this module contains **no regular expressions at all** — so worst-case
+* time is linear in the line length by construction. There is no
+* backtracking engine to feed, no polynomial blow-up for a scanner to flag,
+* and therefore no input truncation.
+*
+* Beyond the whole-line parsers, {@link harvestReferenceLists} generalizes
+* the same list grammar to the inline-in-prose posture — several lists on
+* one line of running text — and {@link parseClosingLists} /
+* {@link parseReferenceLists} apply the whole-line parsers per line of a
+* multi-line text. All of them ride the same character scan; the no-regex
+* promise above covers every export here.
+*/
+/**
+* The non-closing reference keywords the list dialect accepts, lowercased.
+*
+* @remarks
+* GitHub does not act on these — they associate without closing — but a
+* references region writes them, so the parser must read them.
+*
+* @public
+*/
+const REFERENCE_KEYWORDS = [
+	"ref",
+	"refs",
+	"references"
+];
+/**
+* Both keyword tables ARE the exported constants — membership sets built from
+* them once — so the constants and the grammar cannot drift.
+*/
+const ALL_KEYWORDS = /* @__PURE__ */ new Set([...CLOSING_KEYWORDS, ...REFERENCE_KEYWORDS]);
+/** Membership test for reporting `closing`, widened once so no call casts. */
+const CLOSING_SET = new Set(CLOSING_KEYWORDS);
+const HASH = 35;
+const COLON = 58;
+const COMMA = 44;
+/** `[ \t]` — the only whitespace the dialect admits, per the module remarks. */
+const isSpaceTab = (code) => code === 32 || code === 9;
+const isDigit$2 = (code) => code >= 48 && code <= 57;
+const isAsciiLetter = (code) => code >= 65 && code <= 90 || code >= 97 && code <= 122;
+/** The index after the run of `[ \t]` starting at `from` (possibly `from` itself). */
+const skipSpaceTab = (line, from) => {
+	let index = from;
+	while (index < line.length && isSpaceTab(line.charCodeAt(index))) index += 1;
+	return index;
+};
+/**
+* One list item at exactly `from`: `#<digits>` and the index one past it.
+* Digits exceeding `Number.MAX_SAFE_INTEGER` report `"unsafe"` rather than a
+* silently rounded issue number, still carrying the index one past the digit
+* run so a caller can skip the item's extent; the whole-line parsers reject
+* on it and {@link harvestReferenceLists} abandons the entire candidate —
+* see the module remarks for why a list never yields a partial reading.
+* Anything that is not `#<digits>` at all is `undefined`.
+*/
+const readItem = (line, from) => {
+	if (line.charCodeAt(from) !== HASH) return void 0;
+	const start = from + 1;
+	let index = start;
+	while (index < line.length && isDigit$2(line.charCodeAt(index))) index += 1;
+	if (index === start) return void 0;
+	const value = Number(line.slice(start, index));
+	return Number.isSafeInteger(value) ? {
+		kind: "item",
+		value,
+		next: index
+	} : {
+		kind: "unsafe",
+		next: index
+	};
+};
+/**
+* One separator at exactly `from`: a comma with optional surrounding `[ \t]`
+* and an optional Oxford `and` (consumed only when its own trailing `[ \t]+`
+* is present), or a bare `and` requiring `[ \t]+` on both sides. `and` is
+* lowercase-only — the keyword head is case-insensitive, the separator is
+* not. Returns the index where the next item must start, or `undefined` when
+* no separator is present.
+*/
+const scanSeparator = (line, from) => {
+	const afterLeading = skipSpaceTab(line, from);
+	if (line.charCodeAt(afterLeading) === COMMA) {
+		const afterComma = skipSpaceTab(line, afterLeading + 1);
+		if (line.startsWith("and", afterComma)) {
+			const afterAnd = skipSpaceTab(line, afterComma + 3);
+			if (afterAnd > afterComma + 3) return afterAnd;
+		}
+		return afterComma;
+	}
+	if (afterLeading > from && line.startsWith("and", afterLeading)) {
+		const afterAnd = skipSpaceTab(line, afterLeading + 3);
+		if (afterAnd > afterLeading + 3) return afterAnd;
+	}
+};
+/**
+* The scan walk: item, then separator, then item, until the cursor stands
+* exactly at the end of the string. Anything else — a malformed item, an
+* unknown separator, trailing content, an unsafe issue number — is
+* `undefined`, and the caller rejects the whole line.
+*/
+const parseItems = (line, from) => {
+	const issueNumbers = [];
+	let cursor = from;
+	for (;;) {
+		const item = readItem(line, cursor);
+		if (item === void 0 || item.kind === "unsafe") return void 0;
+		issueNumbers.push(item.value);
+		cursor = item.next;
+		if (cursor === line.length) return issueNumbers;
+		const next = scanSeparator(line, cursor);
+		if (next === void 0) return void 0;
+		cursor = next;
+	}
+};
+/**
+* The list a whole line carries under either keyword set, or `Option.none()`.
+*
+* @remarks
+* Accepts the nine closing keywords plus {@link REFERENCE_KEYWORDS}, and
+* reports which set matched in the result's `closing` flag. Grammar,
+* whole-line posture and the whole-line rejection of unsafe issue numbers
+* are in the module remarks.
+*
+* @public
+*/
+const parseReferenceList = (line) => {
+	const trimmed = line.trim();
+	let letters = 0;
+	while (letters < trimmed.length && isAsciiLetter(trimmed.charCodeAt(letters))) letters += 1;
+	if (letters === 0) return Option.none();
+	const keyword = trimmed.slice(0, letters).toLowerCase();
+	if (!ALL_KEYWORDS.has(keyword)) return Option.none();
+	let cursor = letters;
+	if (trimmed.charCodeAt(cursor) === COLON) cursor += 1;
+	const afterWhitespace = skipSpaceTab(trimmed, cursor);
+	if (afterWhitespace === cursor) return Option.none();
+	const issueNumbers = parseItems(trimmed, afterWhitespace);
+	if (issueNumbers === void 0) return Option.none();
+	return Option.some({
+		keyword,
+		closing: CLOSING_SET.has(keyword),
+		issueNumbers
+	});
+};
+/**
+* Every reference list a text carries, line by line, across both postures.
+*
+* @remarks
+* The trailer/prose interleave consumers otherwise hand-roll: each line is
+* tried as a whole-line reference list first ({@link parseReferenceList} —
+* colon-tolerant, per the line dialect), and only a line that is not one is
+* harvested inline ({@link harvestReferenceLists} — no colon, per the inline
+* dialect). The preference means a colon-less trailer line contributes its
+* list exactly once, never once per posture.
+*
+* Results carry no offsets, deliberately: this is the line-granular
+* composition, and a consumer that needs spans uses
+* {@link harvestReferenceLists} directly. Duplicates are preserved, in
+* document order.
+*
+* @public
+*/
+const collectReferenceLists = (text) => {
+	const lists = [];
+	for (const line of text.split("\n")) {
+		const whole = parseReferenceList(line);
+		if (Option.isSome(whole)) {
+			lists.push(whole.value);
+			continue;
+		}
+		for (const harvested of harvestReferenceLists(line)) lists.push({
+			keyword: harvested.keyword,
+			closing: harvested.closing,
+			issueNumbers: harvested.issueNumbers
+		});
+	}
+	return lists;
+};
+/** `[A-Za-z0-9_]` — the word-boundary alphabet the inline dialects use. */
+const isWordChar = (code) => isAsciiLetter(code) || isDigit$2(code) || code === 95;
+/**
+* The full JavaScript `\s` set, spelled as a predicate so the module keeps
+* its no-regex promise: ASCII whitespace, NEL-adjacent controls, and the
+* Unicode space separators. Only the keyword→first-item gap of
+* {@link harvestReferenceLists} admits this set — everything inside a list
+* stays `[ \t]`, per the module remarks.
+*/
+const isAnyWhitespace = (code) => code === 32 || code >= 9 && code <= 13 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288 || code === 65279;
+/**
+* Every reference list found inline in `text`, in document order.
+*
+* @remarks
+* The inline-in-prose posture generalized to lists:
+* `Closes #123, Fixes #456` in one line of a commit body yields two
+* single-item lists, where
+* `harvestIssueReferences` reads only the first reference of each and the
+* whole-line parsers read neither. The grammar per candidate:
+*
+* - The keyword is case-insensitive, drawn from either keyword set,
+*   lowercased to canonical form in the result, with `closing` reported by
+*   set membership. Word boundaries hold on both sides: the characters
+*   immediately before and after the keyword's letter run must not be
+*   `[A-Za-z0-9_]`, so `recloses #1` and `1closes #1` do not match.
+* - **No colon** — exactly like `harvestIssueReferences`, the colon spelling
+*   belongs to the line dialects ({@link parseReferenceList} and the
+*   bare-line parser), so `closes: #1` inline yields nothing.
+* - The keyword→first-item gap is any run of whitespace **including
+*   newlines**, mirroring the inline dialect's `\s+`.
+* - List continuation uses the `,` / `and` / Oxford separators with `[ \t]`
+*   whitespace only, so a list cannot continue past a newline — a later
+*   line makes its own claims.
+* - Items are `#<digits>`; duplicates are preserved in order.
+*
+* A list ends at its last valid item: in `closes #1 and fixes #2` the
+* ` and ` before `fixes` fails as a separator because what follows is not
+* `#`, so the text yields `closes: [1]` then `fixes: [2]`. An item past
+* `Number.MAX_SAFE_INTEGER` anywhere in a candidate skips the **entire**
+* candidate — never a partial list, for the same reason
+* {@link parseReferenceList} rejects the whole line — and scanning resumes
+* after the candidate's scanned extent.
+*
+* Like everything in this module, the harvest is a single left-to-right
+* character scan with no regular expressions, so time stays linear in the
+* text length and no input is truncated.
+*
+* @public
+*/
+const harvestReferenceLists = (text) => {
+	const lists = [];
+	let index = 0;
+	while (index < text.length) {
+		if (!isAsciiLetter(text.charCodeAt(index))) {
+			index += 1;
+			continue;
+		}
+		const runStart = index;
+		let runEnd = index + 1;
+		while (runEnd < text.length && isAsciiLetter(text.charCodeAt(runEnd))) runEnd += 1;
+		if (runStart > 0 && isWordChar(text.charCodeAt(runStart - 1)) || runEnd < text.length && isWordChar(text.charCodeAt(runEnd))) {
+			index = runEnd;
+			continue;
+		}
+		const keyword = text.slice(runStart, runEnd).toLowerCase();
+		if (!ALL_KEYWORDS.has(keyword)) {
+			index = runEnd;
+			continue;
+		}
+		let cursor = runEnd;
+		while (cursor < text.length && isAnyWhitespace(text.charCodeAt(cursor))) cursor += 1;
+		const first = cursor === runEnd ? void 0 : readItem(text, cursor);
+		if (first === void 0) {
+			index = runEnd;
+			continue;
+		}
+		if (first.kind === "unsafe") {
+			index = first.next;
+			continue;
+		}
+		const issueNumbers = [first.value];
+		let end = first.next;
+		let unsafeNext;
+		for (;;) {
+			const next = scanSeparator(text, end);
+			if (next === void 0) break;
+			const item = readItem(text, next);
+			if (item === void 0) break;
+			if (item.kind === "unsafe") {
+				unsafeNext = item.next;
+				break;
+			}
+			issueNumbers.push(item.value);
+			end = item.next;
+		}
+		if (unsafeNext !== void 0) {
+			index = unsafeNext;
+			continue;
+		}
+		lists.push({
+			keyword,
+			closing: CLOSING_SET.has(keyword),
+			issueNumbers,
+			start: runStart,
+			end
+		});
+		index = end;
+	}
+	return lists;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@effected+github-references@0.3.0_effect@4.0.0-rc.115/node_modules/@effected/github-references/KeywordFamily.js
+/**
+* The projection table IS the totality proof: `Record` over the union of
+* both keyword types makes a keyword added to either constant without an
+* entry here fail to compile.
+*/
+const FAMILIES = {
+	close: "close",
+	closes: "close",
+	closed: "close",
+	fix: "fix",
+	fixes: "fix",
+	fixed: "fix",
+	resolve: "resolve",
+	resolves: "resolve",
+	resolved: "resolve",
+	ref: "ref",
+	refs: "ref",
+	references: "ref"
+};
+/**
+* The family a keyword belongs to.
+*
+* @remarks
+* Total over both keyword sets by construction — see the module remarks for
+* why an explicit record beats a `startsWith` heuristic. `close`, `closes`
+* and `closed` map to `"close"`; the `fix` and `resolve` conjugations
+* likewise; `ref`, `refs` and `references` map to `"ref"`. The evidence for
+* the projection is downstream: categorized harvesters key maps by family,
+* and each was hand-rolling this collapse.
+*
+* @public
+*/
+const keywordFamily = (keyword) => FAMILIES[keyword];
+
+//#endregion
+//#region ../silk-core/dist/dev/pkg/schemas/VersioningSchemas.js
 /**
 * Configuration for how private packages are handled during versioning.
 *
@@ -165,7 +609,7 @@ const ChangesetConfigFile = Schema.Struct({
 *
 * @remarks
 * Extends {@link (ChangesetConfigFile:type)} with a `_isSilk` marker flag that is automatically
-* set to `true`. Detected by {@link ChangesetConfigReader} when the `changelog` field
+* set to `true`. Detected by `ChangesetConfigReader` when the `changelog` field
 * references `@savvy-web/changesets`.
 *
 * @since 0.1.0
@@ -176,6 +620,26 @@ const SilkChangesetConfigFile = Schema.Struct({
 	_isSilk: Schema.Boolean.pipe(Schema.withDecodingDefaultType(Effect.succeed(true)), Schema.withConstructorDefault(Effect.succeed(true)))
 });
 
+//#endregion
+//#region ../silk-core/dist/dev/pkg/utils/TrailingSlash.js
+/**
+* Trim trailing slashes from a string.
+*
+* @remarks
+* Trims trailing slashes with an index scan rather than `/\/+$/`. That regex is
+* unanchored at the start, so the engine retries the match from every position
+* and degrades to O(n²) on a string of many slashes (CodeQL `js/polynomial-redos`).
+* Only a trailing run of slashes is removed; interior slash runs are untouched.
+*
+* @since 0.1.0
+* @public
+*/
+const trimTrailingSlashes = (s) => {
+	let end = s.length;
+	while (end > 0 && s[end - 1] === "/") end -= 1;
+	return s.slice(0, end);
+};
+
 //#endregion
 //#region ../silk-effects/dist/dev/pkg/services/ChangesetConfigReader.js
 /**
@@ -206,8 +670,8 @@ function isSilkChangelog(changelog) {
 *
 * @remarks
 * Automatically detects whether the config uses the Silk changelog adapter
-* (`@savvy-web/changesets`) and decodes as {@link (SilkChangesetConfigFile:type)} or the
-* standard {@link (ChangesetConfigFile:type)} accordingly.
+* (`@savvy-web/changesets`) and decodes as `SilkChangesetConfigFile` or the
+* standard `ChangesetConfigFile` accordingly.
 *
 * @example
 * ```typescript
@@ -285,33 +749,6 @@ var ChangesetConfigReader = class extends Context.Service()("@savvy-web/silk-eff
 	}));
 };
 
-//#endregion
-//#region ../silk-effects/dist/dev/pkg/errors/PublishTargetBindingError.js
-/**
-* Raised when publishability detection selects a directory that the package's
-* `dist/prod/targets.json` binding does not describe.
-*
-* @remarks
-* The bundler's prod build writes `targets.json` naming every byte-group
-* directory it produced. Once that binding exists it is authoritative: the only
-* directories whose bytes may be published are the ones it lists. A detector
-* that returns anything else — most often `publishConfig.directory` pointing at
-* a **dev** build, because silk mode was misdetected — is about to pack an
-* unresolved workspace manifest and ship it to a registry.
-*
-* That is the `yaml-effect@0.7.1` failure: detection picked `dist/dev/pkg`, the
-* dev manifest still carried `catalog:` specifiers, and the published package
-* was uninstallable (`EUNSUPPORTEDPROTOCOL`).
-*
-* @since 3.1.0
-* @public
-*/
-var PublishTargetBindingError = class extends Data.TaggedError("PublishTargetBindingError") {
-	get message() {
-		return `Package ${this.pkg} resolved publish directory "${this.directory}", which is not one of the directories bound by dist/prod/targets.json (${this.boundDirectories.join(", ")}). This means publishability detection did not select the prod build output — refusing to publish before packing an unresolved manifest.`;
-	}
-};
-
 //#endregion
 //#region ../silk-effects/dist/dev/pkg/services/ChangesetConfig.js
 const isSilk = (cfg) => "_isSilk" in cfg && cfg._isSilk === true;
@@ -389,23 +826,6 @@ var ChangesetConfig = class ChangesetConfig extends Context.Service()("@savvy-we
 	}));
 };
 
-//#endregion
-//#region ../silk-effects/dist/dev/pkg/utils/TrailingSlash.js
-/**
-* Trim trailing slashes from a string.
-*
-* @remarks
-* Trims trailing slashes with an index scan rather than `/\/+$/`. That regex is
-* unanchored at the start, so the engine retries the match from every position
-* and degrades to O(n²) on a string of many slashes (CodeQL `js/polynomial-redos`).
-* Only a trailing run of slashes is removed; interior slash runs are untouched.
-*/
-const trimTrailingSlashes = (s) => {
-	let end = s.length;
-	while (end > 0 && s[end - 1] === "/") end -= 1;
-	return s.slice(0, end);
-};
-
 //#endregion
 //#region ../silk-effects/dist/dev/pkg/services/SilkPublishability.js
 const NPM_DEFAULT = "https://registry.npmjs.org/";
@@ -529,7 +949,7 @@ var SilkPublishability = class SilkPublishability {
 	* directories it names. A directory outside the binding means detection did
 	* not select the prod output — the `yaml-effect@0.7.1` shape, where a dev
 	* manifest carrying `catalog:` specifiers was packed and published. Rather
-	* than ship those bytes, fail with {@link PublishTargetBindingError}.
+	* than ship those bytes, fail with `PublishTargetBindingError`.
 	*
 	* Before the prod build runs there is no binding, and the detector's
 	* placeholder directories are left alone.
@@ -2671,6 +3091,67 @@ function makeGitHubTest(responses) {
 	} });
 }
 
+//#endregion
+//#region ../silk-effects/dist/dev/pkg/changesets/utils/logger.js
+/**
+* Warning output for changelog generation, parameterised by a
+* {@link ChangesetLogMode} reference instead of an ambient environment read.
+*
+* @remarks
+* This module is engine code shared by every front end, so it must not read
+* `process` — a `process.env` read here would bake one host's environment
+* into every other. The mode is a `Context.Reference` with a default of
+* `"stderr"`; a front end that knows it runs under GitHub Actions or a test
+* runner provides `"github"` or `"silent"` from its own `process.env` read.
+*
+* @packageDocumentation
+*/
+/**
+* The reference that selects the {@link ChangesetLogModeValue}.
+*
+* @remarks
+* Defaults to `"stderr"` when no front end provides it, so a program that
+* never touches the reference still reports. Provide with
+* `Layer.succeed(ChangesetLogMode, "github")` or
+* `Effect.provideService(ChangesetLogMode, "silent")`.
+*
+* @example
+* ```typescript
+* import { Effect } from "effect";
+* import { Changesets } from "\@savvy-web/silk-effects";
+*
+* const mode = process.env.GITHUB_ACTIONS === "true" ? "github" : "stderr";
+* program.pipe(Effect.provideService(Changesets.ChangesetLogMode, mode));
+* ```
+*
+* @public
+*/
+const ChangesetLogMode = Context.Reference("@savvy-web/silk-effects/Changesets/ChangesetLogMode", { defaultValue: () => "stderr" });
+/**
+* Log a warning message according to the {@link ChangesetLogMode} in context.
+*
+* @param message - The warning message
+* @param args - Additional arguments (concatenated with a space in `"github"` mode)
+* @returns An `Effect` that never fails
+*
+* @internal
+*/
+function logWarning(message, ...args) {
+	return Effect.gen(function* () {
+		switch (yield* ChangesetLogMode) {
+			case "silent": return;
+			case "github": {
+				const text = args.length > 0 ? `${message} ${args.join(" ")}` : message;
+				console.warn(`::warning::${text}`);
+				return;
+			}
+			case "stderr":
+				console.warn(message, ...args);
+				return;
+		}
+	});
+}
+
 //#endregion
 //#region ../silk-effects/dist/dev/pkg/changesets/schemas/primitives.js
 /**
@@ -3994,7 +4475,7 @@ function evaluateNode(node, depth) {
 //#region ../../node_modules/.pnpm/@effected+jsonc@0.11.0_effect@4.0.0-rc.115/node_modules/@effected/jsonc/internal/scanner.js
 const isWhitespace = (ch) => ch === 32 || ch === 9 || ch === 11 || ch === 12 || ch === 160 || ch === 65279;
 const isLineBreak$1 = (ch) => ch === 10 || ch === 13 || ch === 8232 || ch === 8233;
-const isDigit$2 = (ch) => ch >= 48 && ch <= 57;
+const isDigit$1 = (ch) => ch >= 48 && ch <= 57;
 /**
 * Create a stateful {@link Scanner} for the given JSONC string.
 *
@@ -4099,31 +4580,31 @@ const createScanner$1 = (text, ignoreTrivia = false) => {
 		if (text.charCodeAt(pos) === 45) pos++;
 		if (text.charCodeAt(pos) === 48) pos++;
 		else {
-			if (!isDigit$2(text.charCodeAt(pos))) {
+			if (!isDigit$1(text.charCodeAt(pos))) {
 				tokenError = "UnexpectedEndOfNumber";
 				return text.substring(start, pos);
 			}
 			pos++;
-			while (pos < len && isDigit$2(text.charCodeAt(pos))) pos++;
+			while (pos < len && isDigit$1(text.charCodeAt(pos))) pos++;
 		}
 		if (pos < len && text.charCodeAt(pos) === 46) {
 			pos++;
-			if (!isDigit$2(text.charCodeAt(pos))) {
+			if (!isDigit$1(text.charCodeAt(pos))) {
 				tokenError = "UnexpectedEndOfNumber";
 				return text.substring(start, pos);
 			}
 			pos++;
-			while (pos < len && isDigit$2(text.charCodeAt(pos))) pos++;
+			while (pos < len && isDigit$1(text.charCodeAt(pos))) pos++;
 		}
 		if (pos < len && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
 			pos++;
 			if (pos < len && (text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45)) pos++;
-			if (!isDigit$2(text.charCodeAt(pos))) {
+			if (!isDigit$1(text.charCodeAt(pos))) {
 				tokenError = "UnexpectedEndOfNumber";
 				return text.substring(start, pos);
 			}
 			pos++;
-			while (pos < len && isDigit$2(text.charCodeAt(pos))) pos++;
+			while (pos < len && isDigit$1(text.charCodeAt(pos))) pos++;
 		}
 		return text.substring(start, pos);
 	};
@@ -4229,7 +4710,7 @@ const createScanner$1 = (text, ignoreTrivia = false) => {
 				return token;
 			}
 			case 45:
-				if (pos + 1 < len && isDigit$2(text.charCodeAt(pos + 1))) {
+				if (pos + 1 < len && isDigit$1(text.charCodeAt(pos + 1))) {
 					tokenValue = scanNumber();
 					token = "Number";
 					return token;
@@ -4240,7 +4721,7 @@ const createScanner$1 = (text, ignoreTrivia = false) => {
 				tokenError = "InvalidSymbol";
 				return token;
 			default:
-				if (isDigit$2(ch)) {
+				if (isDigit$1(ch)) {
 					tokenValue = scanNumber();
 					token = "Number";
 					return token;
@@ -31296,423 +31777,6 @@ function parseCommitMessage(message) {
 	return { description: message };
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/@effected+github-references@0.3.0_effect@4.0.0-rc.115/node_modules/@effected/github-references/IssueReferences.js
-/**
-* GitHub's closing-keyword issue-reference grammar, as pure functions.
-*
-* @remarks
-* GitHub links an issue to a pull request when the PR's description carries
-* `<keyword> #<number>` for one of nine documented keywords. Consumers speak
-* that grammar in two distinct dialects, and this module models exactly those
-* two — no service, no layer, nothing but strings in and values out:
-*
-* - **Inline-in-prose** ({@link harvestIssueReferences}): a reference may appear anywhere in
-*   running text — `"fixes #12 and closes #13"` — with mandatory whitespace
-*   and **no colon**, because that is the spelling GitHub itself scans PR
-*   bodies for. This is the dialect a release pipeline harvests from commit
-*   subjects and PR descriptions.
-* - **Bare-line** ({@link parseBareLineReference}): the whole line, after trimming, *is*
-*   the reference — `"Closes: #12"` — with an **optional colon**, because a
-*   generated references region writes one reference per line and a colon
-*   reads better there. GitHub does not require the colon; the region format
-*   allows it, so the parser must too. The dialects differ because their
-*   producers do: prose is written by humans for GitHub's scanner, the region
-*   is written by tooling for humans.
-*
-* Deliberately out of scope this round: cross-repo references
-* (`owner/repo#N`) and full-URL references
-* (`https://github.com/owner/repo/issues/N`). Both are real GitHub spellings;
-* neither dialect's consumers emit them yet, and guessing at their shape here
-* would freeze an API nobody has driven.
-*/
-/**
-* The nine closing keywords GitHub documents, lowercased.
-*
-* @public
-*/
-const CLOSING_KEYWORDS = [
-	"close",
-	"closes",
-	"closed",
-	"fix",
-	"fixes",
-	"fixed",
-	"resolve",
-	"resolves",
-	"resolved"
-];
-/**
-* Both patterns derive from {@link CLOSING_KEYWORDS} so the constant and the
-* grammar cannot drift. Alternation order is safe: the regex engine backtracks
-* through alternatives, so `close` matching inside `closes` fails at the
-* mandatory `#`-introducer and retries the longer keyword.
-*/
-const KEYWORDS = CLOSING_KEYWORDS.join("|");
-/** Inline-in-prose: mandatory whitespace, no colon. */
-const INLINE_PATTERN = new RegExp(`\\b(${KEYWORDS})\\s+#(\\d+)`, "gi");
-/**
-* Bare-line: optional colon, then mandatory same-line whitespace. `[ \t]`
-* rather than `\s`, so an embedded newline cannot smuggle two lines past a
-* parser whose contract is one.
-*/
-const BARE_LINE_PATTERN = new RegExp(`^(${KEYWORDS}):?[ \\t]+#(\\d+)$`, "i");
-
-//#endregion
-//#region ../../node_modules/.pnpm/@effected+github-references@0.3.0_effect@4.0.0-rc.115/node_modules/@effected/github-references/ClosingList.js
-/**
-* The closing-list dialect: one whole line naming several issues at once.
-*
-* @remarks
-* The third dialect, alongside the two in `IssueReferences`: after trimming,
-* the **entire** line must be `<keyword>[:] <list>` — keyword
-* case-insensitive (lowercased to canonical form in the result), colon
-* optional, and the list one or more `#<digits>` items separated by `,`,
-* `and`, or the Oxford `, and`. Whitespace inside the line is `[ \t]` only,
-* so an embedded newline cannot smuggle two lines past a parser whose
-* contract is one — the same posture as the bare-line pattern. Any trailing
-* content after the list rejects the line; duplicates are preserved in order,
-* because whether `#1, #1` means one issue or two is the caller's business.
-*
-* Two keyword sets play here. {@link parseClosingList} accepts only the nine
-* closing keywords and yields a {@link ClosingList}; {@link parseReferenceList}
-* additionally accepts the non-closing {@link REFERENCE_KEYWORDS} (`ref`,
-* `refs`, `references`) and reports which set matched via
-* {@link ReferenceList}'s `closing` flag.
-*
-* An item whose digits exceed `Number.MAX_SAFE_INTEGER` rejects the **whole
-* line**, where `harvestIssueReferences` merely skips the one match. The
-* asymmetry is deliberate: a harvest drops one reference out of running
-* prose, but a list line is a single claim about a set of issues, and
-* returning the parseable subset would misrepresent the line as claiming
-* less than it does.
-*
-* Complexity posture: parsing is a single left-to-right character scan —
-* this module contains **no regular expressions at all** — so worst-case
-* time is linear in the line length by construction. There is no
-* backtracking engine to feed, no polynomial blow-up for a scanner to flag,
-* and therefore no input truncation.
-*
-* Beyond the whole-line parsers, {@link harvestReferenceLists} generalizes
-* the same list grammar to the inline-in-prose posture — several lists on
-* one line of running text — and {@link parseClosingLists} /
-* {@link parseReferenceLists} apply the whole-line parsers per line of a
-* multi-line text. All of them ride the same character scan; the no-regex
-* promise above covers every export here.
-*/
-/**
-* The non-closing reference keywords the list dialect accepts, lowercased.
-*
-* @remarks
-* GitHub does not act on these — they associate without closing — but a
-* references region writes them, so the parser must read them.
-*
-* @public
-*/
-const REFERENCE_KEYWORDS = [
-	"ref",
-	"refs",
-	"references"
-];
-/**
-* Both keyword tables ARE the exported constants — membership sets built from
-* them once — so the constants and the grammar cannot drift.
-*/
-const ALL_KEYWORDS = /* @__PURE__ */ new Set([...CLOSING_KEYWORDS, ...REFERENCE_KEYWORDS]);
-/** Membership test for reporting `closing`, widened once so no call casts. */
-const CLOSING_SET = new Set(CLOSING_KEYWORDS);
-const HASH = 35;
-const COLON = 58;
-const COMMA = 44;
-/** `[ \t]` — the only whitespace the dialect admits, per the module remarks. */
-const isSpaceTab = (code) => code === 32 || code === 9;
-const isDigit$1 = (code) => code >= 48 && code <= 57;
-const isAsciiLetter = (code) => code >= 65 && code <= 90 || code >= 97 && code <= 122;
-/** The index after the run of `[ \t]` starting at `from` (possibly `from` itself). */
-const skipSpaceTab = (line, from) => {
-	let index = from;
-	while (index < line.length && isSpaceTab(line.charCodeAt(index))) index += 1;
-	return index;
-};
-/**
-* One list item at exactly `from`: `#<digits>` and the index one past it.
-* Digits exceeding `Number.MAX_SAFE_INTEGER` report `"unsafe"` rather than a
-* silently rounded issue number, still carrying the index one past the digit
-* run so a caller can skip the item's extent; the whole-line parsers reject
-* on it and {@link harvestReferenceLists} abandons the entire candidate —
-* see the module remarks for why a list never yields a partial reading.
-* Anything that is not `#<digits>` at all is `undefined`.
-*/
-const readItem = (line, from) => {
-	if (line.charCodeAt(from) !== HASH) return void 0;
-	const start = from + 1;
-	let index = start;
-	while (index < line.length && isDigit$1(line.charCodeAt(index))) index += 1;
-	if (index === start) return void 0;
-	const value = Number(line.slice(start, index));
-	return Number.isSafeInteger(value) ? {
-		kind: "item",
-		value,
-		next: index
-	} : {
-		kind: "unsafe",
-		next: index
-	};
-};
-/**
-* One separator at exactly `from`: a comma with optional surrounding `[ \t]`
-* and an optional Oxford `and` (consumed only when its own trailing `[ \t]+`
-* is present), or a bare `and` requiring `[ \t]+` on both sides. `and` is
-* lowercase-only — the keyword head is case-insensitive, the separator is
-* not. Returns the index where the next item must start, or `undefined` when
-* no separator is present.
-*/
-const scanSeparator = (line, from) => {
-	const afterLeading = skipSpaceTab(line, from);
-	if (line.charCodeAt(afterLeading) === COMMA) {
-		const afterComma = skipSpaceTab(line, afterLeading + 1);
-		if (line.startsWith("and", afterComma)) {
-			const afterAnd = skipSpaceTab(line, afterComma + 3);
-			if (afterAnd > afterComma + 3) return afterAnd;
-		}
-		return afterComma;
-	}
-	if (afterLeading > from && line.startsWith("and", afterLeading)) {
-		const afterAnd = skipSpaceTab(line, afterLeading + 3);
-		if (afterAnd > afterLeading + 3) return afterAnd;
-	}
-};
-/**
-* The scan walk: item, then separator, then item, until the cursor stands
-* exactly at the end of the string. Anything else — a malformed item, an
-* unknown separator, trailing content, an unsafe issue number — is
-* `undefined`, and the caller rejects the whole line.
-*/
-const parseItems = (line, from) => {
-	const issueNumbers = [];
-	let cursor = from;
-	for (;;) {
-		const item = readItem(line, cursor);
-		if (item === void 0 || item.kind === "unsafe") return void 0;
-		issueNumbers.push(item.value);
-		cursor = item.next;
-		if (cursor === line.length) return issueNumbers;
-		const next = scanSeparator(line, cursor);
-		if (next === void 0) return void 0;
-		cursor = next;
-	}
-};
-/**
-* The list a whole line carries under either keyword set, or `Option.none()`.
-*
-* @remarks
-* Accepts the nine closing keywords plus {@link REFERENCE_KEYWORDS}, and
-* reports which set matched in the result's `closing` flag. Grammar,
-* whole-line posture and the whole-line rejection of unsafe issue numbers
-* are in the module remarks.
-*
-* @public
-*/
-const parseReferenceList = (line) => {
-	const trimmed = line.trim();
-	let letters = 0;
-	while (letters < trimmed.length && isAsciiLetter(trimmed.charCodeAt(letters))) letters += 1;
-	if (letters === 0) return Option.none();
-	const keyword = trimmed.slice(0, letters).toLowerCase();
-	if (!ALL_KEYWORDS.has(keyword)) return Option.none();
-	let cursor = letters;
-	if (trimmed.charCodeAt(cursor) === COLON) cursor += 1;
-	const afterWhitespace = skipSpaceTab(trimmed, cursor);
-	if (afterWhitespace === cursor) return Option.none();
-	const issueNumbers = parseItems(trimmed, afterWhitespace);
-	if (issueNumbers === void 0) return Option.none();
-	return Option.some({
-		keyword,
-		closing: CLOSING_SET.has(keyword),
-		issueNumbers
-	});
-};
-/**
-* Every reference list a text carries, line by line, across both postures.
-*
-* @remarks
-* The trailer/prose interleave consumers otherwise hand-roll: each line is
-* tried as a whole-line reference list first ({@link parseReferenceList} —
-* colon-tolerant, per the line dialect), and only a line that is not one is
-* harvested inline ({@link harvestReferenceLists} — no colon, per the inline
-* dialect). The preference means a colon-less trailer line contributes its
-* list exactly once, never once per posture.
-*
-* Results carry no offsets, deliberately: this is the line-granular
-* composition, and a consumer that needs spans uses
-* {@link harvestReferenceLists} directly. Duplicates are preserved, in
-* document order.
-*
-* @public
-*/
-const collectReferenceLists = (text) => {
-	const lists = [];
-	for (const line of text.split("\n")) {
-		const whole = parseReferenceList(line);
-		if (Option.isSome(whole)) {
-			lists.push(whole.value);
-			continue;
-		}
-		for (const harvested of harvestReferenceLists(line)) lists.push({
-			keyword: harvested.keyword,
-			closing: harvested.closing,
-			issueNumbers: harvested.issueNumbers
-		});
-	}
-	return lists;
-};
-/** `[A-Za-z0-9_]` — the word-boundary alphabet the inline dialects use. */
-const isWordChar = (code) => isAsciiLetter(code) || isDigit$1(code) || code === 95;
-/**
-* The full JavaScript `\s` set, spelled as a predicate so the module keeps
-* its no-regex promise: ASCII whitespace, NEL-adjacent controls, and the
-* Unicode space separators. Only the keyword→first-item gap of
-* {@link harvestReferenceLists} admits this set — everything inside a list
-* stays `[ \t]`, per the module remarks.
-*/
-const isAnyWhitespace = (code) => code === 32 || code >= 9 && code <= 13 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288 || code === 65279;
-/**
-* Every reference list found inline in `text`, in document order.
-*
-* @remarks
-* The inline-in-prose posture generalized to lists:
-* `Closes #123, Fixes #456` in one line of a commit body yields two
-* single-item lists, where
-* `harvestIssueReferences` reads only the first reference of each and the
-* whole-line parsers read neither. The grammar per candidate:
-*
-* - The keyword is case-insensitive, drawn from either keyword set,
-*   lowercased to canonical form in the result, with `closing` reported by
-*   set membership. Word boundaries hold on both sides: the characters
-*   immediately before and after the keyword's letter run must not be
-*   `[A-Za-z0-9_]`, so `recloses #1` and `1closes #1` do not match.
-* - **No colon** — exactly like `harvestIssueReferences`, the colon spelling
-*   belongs to the line dialects ({@link parseReferenceList} and the
-*   bare-line parser), so `closes: #1` inline yields nothing.
-* - The keyword→first-item gap is any run of whitespace **including
-*   newlines**, mirroring the inline dialect's `\s+`.
-* - List continuation uses the `,` / `and` / Oxford separators with `[ \t]`
-*   whitespace only, so a list cannot continue past a newline — a later
-*   line makes its own claims.
-* - Items are `#<digits>`; duplicates are preserved in order.
-*
-* A list ends at its last valid item: in `closes #1 and fixes #2` the
-* ` and ` before `fixes` fails as a separator because what follows is not
-* `#`, so the text yields `closes: [1]` then `fixes: [2]`. An item past
-* `Number.MAX_SAFE_INTEGER` anywhere in a candidate skips the **entire**
-* candidate — never a partial list, for the same reason
-* {@link parseReferenceList} rejects the whole line — and scanning resumes
-* after the candidate's scanned extent.
-*
-* Like everything in this module, the harvest is a single left-to-right
-* character scan with no regular expressions, so time stays linear in the
-* text length and no input is truncated.
-*
-* @public
-*/
-const harvestReferenceLists = (text) => {
-	const lists = [];
-	let index = 0;
-	while (index < text.length) {
-		if (!isAsciiLetter(text.charCodeAt(index))) {
-			index += 1;
-			continue;
-		}
-		const runStart = index;
-		let runEnd = index + 1;
-		while (runEnd < text.length && isAsciiLetter(text.charCodeAt(runEnd))) runEnd += 1;
-		if (runStart > 0 && isWordChar(text.charCodeAt(runStart - 1)) || runEnd < text.length && isWordChar(text.charCodeAt(runEnd))) {
-			index = runEnd;
-			continue;
-		}
-		const keyword = text.slice(runStart, runEnd).toLowerCase();
-		if (!ALL_KEYWORDS.has(keyword)) {
-			index = runEnd;
-			continue;
-		}
-		let cursor = runEnd;
-		while (cursor < text.length && isAnyWhitespace(text.charCodeAt(cursor))) cursor += 1;
-		const first = cursor === runEnd ? void 0 : readItem(text, cursor);
-		if (first === void 0) {
-			index = runEnd;
-			continue;
-		}
-		if (first.kind === "unsafe") {
-			index = first.next;
-			continue;
-		}
-		const issueNumbers = [first.value];
-		let end = first.next;
-		let unsafeNext;
-		for (;;) {
-			const next = scanSeparator(text, end);
-			if (next === void 0) break;
-			const item = readItem(text, next);
-			if (item === void 0) break;
-			if (item.kind === "unsafe") {
-				unsafeNext = item.next;
-				break;
-			}
-			issueNumbers.push(item.value);
-			end = item.next;
-		}
-		if (unsafeNext !== void 0) {
-			index = unsafeNext;
-			continue;
-		}
-		lists.push({
-			keyword,
-			closing: CLOSING_SET.has(keyword),
-			issueNumbers,
-			start: runStart,
-			end
-		});
-		index = end;
-	}
-	return lists;
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/@effected+github-references@0.3.0_effect@4.0.0-rc.115/node_modules/@effected/github-references/KeywordFamily.js
-/**
-* The projection table IS the totality proof: `Record` over the union of
-* both keyword types makes a keyword added to either constant without an
-* entry here fail to compile.
-*/
-const FAMILIES = {
-	close: "close",
-	closes: "close",
-	closed: "close",
-	fix: "fix",
-	fixes: "fix",
-	fixed: "fix",
-	resolve: "resolve",
-	resolves: "resolve",
-	resolved: "resolve",
-	ref: "ref",
-	refs: "ref",
-	references: "ref"
-};
-/**
-* The family a keyword belongs to.
-*
-* @remarks
-* Total over both keyword sets by construction — see the module remarks for
-* why an explicit record beats a `startsWith` heuristic. `close`, `closes`
-* and `closed` map to `"close"`; the `fix` and `resolve` conjugations
-* likewise; `ref`, `refs` and `references` map to `"ref"`. The evidence for
-* the projection is downstream: categorized harvesters key maps by family,
-* and each was hand-rolling this collapse.
-*
-* @public
-*/
-const keywordFamily = (keyword) => FAMILIES[keyword];
-
 //#endregion
 //#region ../silk-effects/dist/dev/pkg/changesets/utils/issue-refs.js
 /**
@@ -31780,42 +31844,6 @@ function parseIssueReferences(commitMessage) {
 	return references;
 }
 
-//#endregion
-//#region ../silk-effects/dist/dev/pkg/changesets/utils/logger.js
-/**
-* Log a warning message.
-*
-* @remarks
-* Detection order:
-* 1. If `process.env.VITEST` is set, the message is silently discarded.
-* 2. If `process.env.GITHUB_ACTIONS === "true"`, the message is emitted
-*    as a `::warning::` annotation.
-* 3. Otherwise, `console.warn` is used.
-*
-* @param message - The warning message
-* @param args - Additional arguments (concatenated with a space in CI mode)
-*
-* @example
-* ```typescript
-* import { logWarning } from "../utils/logger.js";
-*
-* logWarning("Duplicate dependency entry", "effect@3.19.0");
-* // In CI: "::warning::Duplicate dependency entry effect@3.19.0"
-* // Locally: console.warn("Duplicate dependency entry", "effect@3.19.0")
-* ```
-*
-* @internal
-*/
-function logWarning(message, ...args) {
-	/* v8 ignore start — environment-specific */
-	if (typeof process !== "undefined" && process.env.VITEST) return;
-	if (typeof process !== "undefined" && process.env.GITHUB_ACTIONS === "true") {
-		const text = args.length > 0 ? `${message} ${args.join(" ")}` : message;
-		console.warn(`::warning::${text}`);
-	} else console.warn(message, ...args);
-	/* v8 ignore stop */
-}
-
 //#endregion
 //#region ../silk-effects/dist/dev/pkg/changesets/utils/section-parser.js
 /**
@@ -32188,10 +32216,7 @@ function getReleaseLine(changeset, versionType, options) {
 		if (changeset.commit) commitInfo = yield* (yield* GitHubService).getInfo({
 			commit: changeset.commit,
 			repo: options.repo
-		}).pipe(Effect.flatMap((raw) => Schema.decodeUnknownEffect(GitHubInfoSchema)(raw).pipe(Effect.map(() => raw), Effect.catch(() => Effect.succeed(raw)))), Effect.catch((error) => {
-			logWarning("Could not fetch GitHub info for commit:", changeset.commit ?? "", String(error));
-			return Effect.succeed(null);
-		}));
+		}).pipe(Effect.flatMap((raw) => Schema.decodeUnknownEffect(GitHubInfoSchema)(raw).pipe(Effect.map(() => raw), Effect.catch(() => Effect.succeed(raw)))), Effect.catch((error) => logWarning("Could not fetch GitHub info for commit:", changeset.commit ?? "", String(error)).pipe(Effect.as(null))));
 		const parsed = parseChangesetSections(changeset.summary);
 		const firstLine = changeset.summary.split("\n")[0];
 		const commitMsg = parseCommitMessage(firstLine);
@@ -32290,31 +32315,50 @@ function getReleaseLine(changeset, versionType, options) {
 */
 const MainLayer = GitHubService.layer;
 /**
-* Changesets API `ChangelogFunctions` implementation.
+* Build a Changesets `ChangelogFunctions` implementation bound to a warning
+* mode.
 *
-* This object satisfies the `ChangelogFunctions` contract from
-* `\@changesets/types`. Each method validates options, runs the
-* corresponding Effect program with the merged service layer, and
-* returns a `Promise<string>`.
+* @remarks
+* This module is engine code and reads no environment; the host that installs
+* the functions (the `\@savvy-web/changelog` package under the changesets CLI)
+* decides the mode from its own `process.env` and passes it here. Each method
+* validates options, runs the corresponding Effect program with the merged
+* service layer and the chosen {@link ChangesetLogMode}, and returns a
+* `Promise<string>`.
 *
-* @internal
+* @param options - The warning mode to provide
+* @returns A `ChangelogFunctions` object for `.changeset/config.json`
+*
+* @public
 */
-const changelogFunctions$1 = {
-	getReleaseLine: async (changeset, versionType, options) => {
-		const program = Effect.gen(function* () {
+function makeChangelogFunctions(options = {}) {
+	const run = (program) => {
+		const provided = program.pipe(Effect.provide(MainLayer));
+		return Effect.runPromise(options.logMode === void 0 ? provided : provided.pipe(Effect.provideService(ChangesetLogMode, options.logMode)));
+	};
+	return {
+		getReleaseLine: async (changeset, versionType, options) => run(Effect.gen(function* () {
 			const opts = yield* validateChangesetOptions(options);
 			return yield* getReleaseLine(changeset, versionType, opts);
-		});
-		return Effect.runPromise(program.pipe(Effect.provide(MainLayer)));
-	},
-	getDependencyReleaseLine: async (changesets, dependenciesUpdated, options) => {
-		const program = Effect.gen(function* () {
+		})),
+		getDependencyReleaseLine: async (changesets, dependenciesUpdated, options) => run(Effect.gen(function* () {
 			const opts = yield* validateChangesetOptions(options);
 			return yield* getDependencyReleaseLine(changesets, dependenciesUpdated, opts);
-		});
-		return Effect.runPromise(program.pipe(Effect.provide(MainLayer)));
-	}
-};
+		}))
+	};
+}
+/**
+* Changesets API `ChangelogFunctions` implementation with the default warning
+* mode (`"stderr"`).
+*
+* @remarks
+* Equivalent to `makeChangelogFunctions()`. A host that runs under GitHub
+* Actions or a test runner should call {@link makeChangelogFunctions} with the
+* mode it detects instead.
+*
+* @internal
+*/
+const changelogFunctions$1 = makeChangelogFunctions();
 
 //#endregion
 //#region ../silk-effects/dist/dev/pkg/changesets/api/changelog.js
@@ -32420,10 +32464,13 @@ var Changelog = class {
 	* @param versionType - The semantic version bump type (`"major"`, `"minor"`, or `"patch"`)
 	* @param options - Configuration object; must include `repo` in `"owner/repo"` format.
 	*   Pass `null` to use defaults (no GitHub link resolution).
+	* @param logMode - How a failed GitHub lookup is reported (`"stderr"` when omitted);
+	*   the host reads its own environment and passes `"github"` / `"silent"` — this
+	*   engine never does. See `ChangesetLogMode`.
 	* @returns A promise resolving to the formatted markdown string
 	*/
-	static async formatReleaseLine(changeset, versionType, options) {
-		return changelogFunctions$1.getReleaseLine(changeset, versionType, options);
+	static async formatReleaseLine(changeset, versionType, options, logMode) {
+		return makeChangelogFunctions(logMode === void 0 ? {} : { logMode }).getReleaseLine(changeset, versionType, options);
 	}
 	/**
 	* Format dependency update release lines into a markdown table.
@@ -32438,11 +32485,13 @@ var Changelog = class {
 	*   old/new versions and package metadata
 	* @param options - Configuration object; must include `repo` in `"owner/repo"` format.
 	*   Pass `null` to use defaults.
+	* @param logMode - How a failed GitHub lookup is reported (`"stderr"` when omitted);
+	*   see {@link Changelog.formatReleaseLine}.
 	* @returns A promise resolving to the formatted markdown string containing
 	*   the dependency update table
 	*/
-	static async formatDependencyReleaseLine(changesets, dependenciesUpdated, options) {
-		return changelogFunctions$1.getDependencyReleaseLine(changesets, dependenciesUpdated, options);
+	static async formatDependencyReleaseLine(changesets, dependenciesUpdated, options, logMode) {
+		return makeChangelogFunctions(logMode === void 0 ? {} : { logMode }).getDependencyReleaseLine(changesets, dependenciesUpdated, options);
 	}
 };
 
@@ -41171,7 +41220,7 @@ function globSync(globInput, options) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/identity.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/identity.js
 var require_identity = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const ALIAS = Symbol.for("yaml.alias");
 	const DOC = Symbol.for("yaml.document");
@@ -41222,7 +41271,7 @@ var require_identity = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/visit.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/visit.js
 var require_visit = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	const BREAK = Symbol("break visit");
@@ -41414,7 +41463,7 @@ var require_visit = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/doc/directives.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/doc/directives.js
 var require_directives = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var visit = require_visit();
@@ -41579,7 +41628,7 @@ var require_directives = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/doc/anchors.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/doc/anchors.js
 var require_anchors = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var visit = require_visit();
@@ -41647,7 +41696,7 @@ var require_anchors = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/doc/applyReviver.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/doc/applyReviver.js
 var require_applyReviver = /* @__PURE__ */ __commonJSMin(((exports) => {
 	/**
 	* Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,
@@ -41690,7 +41739,7 @@ var require_applyReviver = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/toJS.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/toJS.js
 var require_toJS = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	/**
@@ -41728,7 +41777,7 @@ var require_toJS = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/Node.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/Node.js
 var require_Node = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var applyReviver = require_applyReviver();
 	var identity = require_identity();
@@ -41763,7 +41812,7 @@ var require_Node = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/Alias.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/Alias.js
 var require_Alias = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var anchors = require_anchors();
 	var visit = require_visit();
@@ -41798,29 +41847,31 @@ var require_Alias = /* @__PURE__ */ __commonJSMin(((exports) => {
 				if (node === this) break;
 				if (node.anchor === this.source) found = node;
 			}
+			if (found && ctx) {
+				const { anchors, doc, maxAliasCount } = ctx;
+				let data = anchors.get(found);
+				if (!data) {
+					toJS.toJS(found, null, ctx);
+					data = anchors.get(found);
+				}
+				/* istanbul ignore if */
+				if (data?.res === void 0) throw new ReferenceError("This should not happen: Alias anchor was not resolved?");
+				if (maxAliasCount >= 0) {
+					data.count += 1;
+					if (data.aliasCount === 0) data.aliasCount = getAliasCount(doc, found, anchors);
+					if (data.count * data.aliasCount > maxAliasCount) throw new ReferenceError("Excessive alias count indicates a resource exhaustion attack");
+				}
+			}
 			return found;
 		}
 		toJSON(_arg, ctx) {
 			if (!ctx) return { source: this.source };
-			const { anchors, doc, maxAliasCount } = ctx;
-			const source = this.resolve(doc, ctx);
+			const source = this.resolve(ctx.doc, ctx);
 			if (!source) {
 				const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
 				throw new ReferenceError(msg);
 			}
-			let data = anchors.get(source);
-			if (!data) {
-				toJS.toJS(source, null, ctx);
-				data = anchors.get(source);
-			}
-			/* istanbul ignore if */
-			if (data?.res === void 0) throw new ReferenceError("This should not happen: Alias anchor was not resolved?");
-			if (maxAliasCount >= 0) {
-				data.count += 1;
-				if (data.aliasCount === 0) data.aliasCount = getAliasCount(doc, source, anchors);
-				if (data.count * data.aliasCount > maxAliasCount) throw new ReferenceError("Excessive alias count indicates a resource exhaustion attack");
-			}
-			return data.res;
+			return ctx.anchors.get(source).res;
 		}
 		toString(ctx, _onComment, _onChompKeep) {
 			const src = `*${this.source}`;
@@ -41858,7 +41909,7 @@ var require_Alias = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/Scalar.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/Scalar.js
 var require_Scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var Node = require_Node();
@@ -41886,7 +41937,7 @@ var require_Scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/doc/createNode.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/doc/createNode.js
 var require_createNode = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Alias = require_Alias();
 	var identity = require_identity();
@@ -41950,7 +42001,7 @@ var require_createNode = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/Collection.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/Collection.js
 var require_Collection = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var createNode = require_createNode();
 	var identity = require_identity();
@@ -42072,7 +42123,7 @@ var require_Collection = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/stringify/stringifyComment.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/stringify/stringifyComment.js
 var require_stringifyComment = /* @__PURE__ */ __commonJSMin(((exports) => {
 	/**
 	* Stringifies a comment.
@@ -42093,7 +42144,7 @@ var require_stringifyComment = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/stringify/foldFlowLines.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/stringify/foldFlowLines.js
 var require_foldFlowLines = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const FOLD_FLOW = "flow";
 	const FOLD_BLOCK = "block";
@@ -42214,7 +42265,7 @@ var require_foldFlowLines = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/stringify/stringifyString.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/stringify/stringifyString.js
 var require_stringifyString = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Scalar = require_Scalar();
 	var foldFlowLines = require_foldFlowLines();
@@ -42439,7 +42490,7 @@ var require_stringifyString = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/stringify/stringify.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/stringify/stringify.js
 var require_stringify$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var anchors = require_anchors();
 	var identity = require_identity();
@@ -42548,7 +42599,7 @@ var require_stringify$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/stringify/stringifyPair.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/stringify/stringifyPair.js
 var require_stringifyPair = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var Scalar = require_Scalar();
@@ -42646,7 +42697,7 @@ var require_stringifyPair = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/log.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/log.js
 var require_log = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var node_process$2 = __require$1("process");
 	function debug(logLevel, ...messages) {
@@ -42663,7 +42714,7 @@ var require_log = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/merge.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/merge.js
 var require_merge = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var Scalar = require_Scalar();
@@ -42707,7 +42758,7 @@ var require_merge = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/addPairToJSMap.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/addPairToJSMap.js
 var require_addPairToJSMap = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var log = require_log();
 	var merge = require_merge();
@@ -42759,7 +42810,7 @@ var require_addPairToJSMap = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/Pair.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/Pair.js
 var require_Pair = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var createNode = require_createNode();
 	var stringifyPair = require_stringifyPair();
@@ -42795,7 +42846,7 @@ var require_Pair = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/stringify/stringifyCollection.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/stringify/stringifyCollection.js
 var require_stringifyCollection = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var stringify = require_stringify$1();
@@ -42914,7 +42965,7 @@ var require_stringifyCollection = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/YAMLMap.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/YAMLMap.js
 var require_YAMLMap = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var stringifyCollection = require_stringifyCollection();
 	var addPairToJSMap = require_addPairToJSMap();
@@ -43024,7 +43075,7 @@ var require_YAMLMap = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/common/map.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/common/map.js
 var require_map = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var YAMLMap = require_YAMLMap();
@@ -43043,7 +43094,7 @@ var require_map = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/nodes/YAMLSeq.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/YAMLSeq.js
 var require_YAMLSeq = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var createNode = require_createNode();
 	var stringifyCollection = require_stringifyCollection();
@@ -43150,7 +43201,7 @@ var require_YAMLSeq = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/common/seq.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/common/seq.js
 var require_seq = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var YAMLSeq = require_YAMLSeq();
@@ -43169,7 +43220,7 @@ var require_seq = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/common/string.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/common/string.js
 var require_string = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var stringifyString = require_stringifyString();
 	const string = {
@@ -43186,7 +43237,7 @@ var require_string = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/common/null.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/common/null.js
 var require_null = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Scalar = require_Scalar();
 	const nullTag = {
@@ -43202,7 +43253,7 @@ var require_null = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/core/bool.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/core/bool.js
 var require_bool$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Scalar = require_Scalar();
 	const boolTag = {
@@ -43222,7 +43273,7 @@ var require_bool$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/stringify/stringifyNumber.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/stringify/stringifyNumber.js
 var require_stringifyNumber = /* @__PURE__ */ __commonJSMin(((exports) => {
 	function stringifyNumber({ format, minFractionDigits, tag, value }) {
 		if (typeof value === "bigint") return String(value);
@@ -43244,7 +43295,7 @@ var require_stringifyNumber = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/core/float.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/core/float.js
 var require_float$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Scalar = require_Scalar();
 	var stringifyNumber = require_stringifyNumber();
@@ -43287,7 +43338,7 @@ var require_float$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/core/int.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/core/int.js
 var require_int$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var stringifyNumber = require_stringifyNumber();
 	const intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
@@ -43329,7 +43380,7 @@ var require_int$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/core/schema.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/core/schema.js
 var require_schema$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var map = require_map();
 	var _null = require_null();
@@ -43355,7 +43406,7 @@ var require_schema$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/json/schema.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/json/schema.js
 var require_schema$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Scalar = require_Scalar();
 	var map = require_map();
@@ -43419,7 +43470,7 @@ var require_schema$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/binary.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/binary.js
 var require_binary = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var node_buffer = __require$1("buffer");
 	var Scalar = require_Scalar();
@@ -43477,7 +43528,7 @@ var require_binary = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/pairs.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/pairs.js
 var require_pairs = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var Pair = require_Pair();
@@ -43539,7 +43590,7 @@ var require_pairs = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/omap.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/omap.js
 var require_omap = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var toJS = require_toJS();
@@ -43605,7 +43656,7 @@ var require_omap = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/bool.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/bool.js
 var require_bool = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Scalar = require_Scalar();
 	function boolStringify({ value, source }, ctx) {
@@ -43633,7 +43684,7 @@ var require_bool = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/float.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/float.js
 var require_float = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Scalar = require_Scalar();
 	var stringifyNumber = require_stringifyNumber();
@@ -43679,7 +43730,7 @@ var require_float = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/int.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/int.js
 var require_int = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var stringifyNumber = require_stringifyNumber();
 	const intIdentify = (value) => typeof value === "bigint" || Number.isInteger(value);
@@ -43753,7 +43804,7 @@ var require_int = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/set.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/set.js
 var require_set = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var Pair = require_Pair();
@@ -43823,7 +43874,7 @@ var require_set = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/timestamp.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/timestamp.js
 var require_timestamp = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var stringifyNumber = require_stringifyNumber();
 	/** Internal types handle bigint as number, because TS can't figure it out. */
@@ -43907,7 +43958,7 @@ var require_timestamp = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/schema.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/yaml-1.1/schema.js
 var require_schema = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var map = require_map();
 	var _null = require_null();
@@ -43949,7 +44000,7 @@ var require_schema = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/tags.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/tags.js
 var require_tags = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var map = require_map();
 	var _null = require_null();
@@ -44036,7 +44087,7 @@ var require_tags = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/schema/Schema.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/schema/Schema.js
 var require_Schema = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var map = require_map();
@@ -44066,7 +44117,7 @@ var require_Schema = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/stringify/stringifyDocument.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/stringify/stringifyDocument.js
 var require_stringifyDocument = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var stringify = require_stringify$1();
@@ -44129,7 +44180,7 @@ var require_stringifyDocument = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/doc/Document.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/doc/Document.js
 var require_Document = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Alias = require_Alias();
 	var Collection = require_Collection();
@@ -44411,7 +44462,7 @@ var require_Document = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/errors.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/errors.js
 var require_errors = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var YAMLError = class extends Error {
 		constructor(name, pos, code, message) {
@@ -44465,7 +44516,7 @@ var require_errors = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/resolve-props.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/resolve-props.js
 var require_resolve_props = /* @__PURE__ */ __commonJSMin(((exports) => {
 	function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) {
 		let spaceBefore = false;
@@ -44573,7 +44624,7 @@ var require_resolve_props = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/util-contains-newline.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/util-contains-newline.js
 var require_util_contains_newline = /* @__PURE__ */ __commonJSMin(((exports) => {
 	function containsNewline(key) {
 		if (!key) return null;
@@ -44603,7 +44654,7 @@ var require_util_contains_newline = /* @__PURE__ */ __commonJSMin(((exports) =>
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/util-flow-indent-check.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/util-flow-indent-check.js
 var require_util_flow_indent_check = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var utilContainsNewline = require_util_contains_newline();
 	function flowIndentCheck(indent, fc, onError) {
@@ -44616,7 +44667,7 @@ var require_util_flow_indent_check = /* @__PURE__ */ __commonJSMin(((exports) =>
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/util-map-includes.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/util-map-includes.js
 var require_util_map_includes = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	function mapIncludes(ctx, items, search) {
@@ -44629,7 +44680,7 @@ var require_util_map_includes = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/resolve-block-map.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/resolve-block-map.js
 var require_resolve_block_map = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Pair = require_Pair();
 	var YAMLMap = require_YAMLMap();
@@ -44718,7 +44769,7 @@ var require_resolve_block_map = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/resolve-block-seq.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/resolve-block-seq.js
 var require_resolve_block_seq = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var YAMLSeq = require_YAMLSeq();
 	var resolveProps = require_resolve_props();
@@ -44764,7 +44815,7 @@ var require_resolve_block_seq = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/resolve-end.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/resolve-end.js
 var require_resolve_end = /* @__PURE__ */ __commonJSMin(((exports) => {
 	function resolveEnd(end, offset, reqSpace, onError) {
 		let comment = "";
@@ -44803,7 +44854,7 @@ var require_resolve_end = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/resolve-flow-collection.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/resolve-flow-collection.js
 var require_resolve_flow_collection = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var Pair = require_Pair();
@@ -44967,7 +45018,7 @@ var require_resolve_flow_collection = /* @__PURE__ */ __commonJSMin(((exports) =
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/compose-collection.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/compose-collection.js
 var require_compose_collection = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var Scalar = require_Scalar();
@@ -45020,7 +45071,7 @@ var require_compose_collection = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/resolve-block-scalar.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/resolve-block-scalar.js
 var require_resolve_block_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Scalar = require_Scalar();
 	function resolveBlockScalar(ctx, scalar, onError) {
@@ -45198,7 +45249,7 @@ var require_resolve_block_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/resolve-flow-scalar.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/resolve-flow-scalar.js
 var require_resolve_flow_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Scalar = require_Scalar();
 	var resolveEnd = require_resolve_end();
@@ -45268,40 +45319,41 @@ var require_resolve_flow_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 			case "`": badChar = `reserved character ${source[0]}`;
 		}
 		if (badChar) onError(0, "BAD_SCALAR_START", `Plain value cannot start with ${badChar}`);
-		return foldLines(source);
+		return unfoldLines(source);
 	}
 	function singleQuotedValue(source, onError) {
 		if (source[source.length - 1] !== "'" || source.length === 1) onError(source.length, "MISSING_CHAR", "Missing closing 'quote");
-		return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+		return unfoldLines(source.slice(1, -1)).replace(/''/g, "'");
 	}
-	function foldLines(source) {
+	function unfoldLines(source) {
+		const line = /(.*?)\r?\n/sy;
+		let match = line.exec(source);
+		if (!match) return source;
 		/**
-		* The negative lookbehind here and in the `re` RegExp is to
+		* The negative lookbehinds in these RegExps are to
 		* prevent causing a polynomial search time in certain cases.
 		*
-		* The try-catch is for Safari, which doesn't support this yet:
+		* The try-catch is for Safari < 16.4 and other old browsers:
 		* https://caniuse.com/js-regexp-lookbehind
 		*/
-		let first, line;
+		let trimEnd, trimBoth;
 		try {
-			first = new RegExp("(.*?)(?<![ 	])[ 	]*\r?\n", "sy");
-			line = new RegExp("[ 	]*(.*?)(?:(?<![ 	])[ 	]*)?\r?\n", "sy");
+			trimEnd = new RegExp("(?<![ 	])[ 	]+$");
+			trimBoth = new RegExp("^[ 	]+|(?<![ 	])[ 	]+$", "g");
 		} catch {
-			first = /(.*?)[ \t]*\r?\n/sy;
-			line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+			trimEnd = /[ \t]+$/;
+			trimBoth = /^[ \t]+|[ \t]+$/g;
 		}
-		let match = first.exec(source);
-		if (!match) return source;
-		let res = match[1];
+		let res = match[1].replace(trimEnd, "");
 		let sep = " ";
-		let pos = first.lastIndex;
-		line.lastIndex = pos;
+		let pos = line.lastIndex;
 		while (match = line.exec(source)) {
-			if (match[1] === "") {
+			const lm = match[1].replace(trimBoth, "");
+			if (lm === "") {
 				if (sep === "\n") res += sep;
 				else sep = "\n";
 			} else {
-				res += sep + match[1];
+				res += sep + lm;
 				sep = " ";
 			}
 			pos = line.lastIndex;
@@ -45403,7 +45455,7 @@ var require_resolve_flow_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/compose-scalar.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/compose-scalar.js
 var require_compose_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var identity = require_identity();
 	var Scalar = require_Scalar();
@@ -45465,7 +45517,7 @@ var require_compose_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/util-empty-scalar-position.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/util-empty-scalar-position.js
 var require_util_empty_scalar_position = /* @__PURE__ */ __commonJSMin(((exports) => {
 	function emptyScalarPosition(offset, before, pos) {
 		if (before) {
@@ -45493,7 +45545,7 @@ var require_util_empty_scalar_position = /* @__PURE__ */ __commonJSMin(((exports
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/compose-node.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/compose-node.js
 var require_compose_node = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Alias = require_Alias();
 	var identity = require_identity();
@@ -45585,7 +45637,7 @@ var require_compose_node = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/compose-doc.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/compose-doc.js
 var require_compose_doc = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var Document = require_Document();
 	var composeNode = require_compose_node();
@@ -45628,7 +45680,7 @@ var require_compose_doc = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/composer.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/compose/composer.js
 var require_composer = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var node_process$1 = __require$1("process");
 	var directives = require_directives();
@@ -45827,7 +45879,7 @@ var require_composer = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/parse/cst-scalar.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/parse/cst-scalar.js
 var require_cst_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var resolveBlockScalar = require_resolve_block_scalar();
 	var resolveFlowScalar = require_resolve_flow_scalar();
@@ -46095,7 +46147,7 @@ var require_cst_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/parse/cst-stringify.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/parse/cst-stringify.js
 var require_cst_stringify = /* @__PURE__ */ __commonJSMin(((exports) => {
 	/**
 	* Stringify a CST document, token, or collection item
@@ -46147,7 +46199,7 @@ var require_cst_stringify = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/parse/cst-visit.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/parse/cst-visit.js
 var require_cst_visit = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const BREAK = Symbol("break visit");
 	const SKIP = Symbol("skip children");
@@ -46239,7 +46291,7 @@ var require_cst_visit = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/parse/cst.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/parse/cst.js
 var require_cst = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var cstScalar = require_cst_scalar();
 	var cstStringify = require_cst_stringify();
@@ -46319,7 +46371,7 @@ var require_cst = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/parse/lexer.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/parse/lexer.js
 var require_lexer = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var cst = require_cst();
 	function isEmpty(ch) {
@@ -46853,7 +46905,7 @@ var require_lexer = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/parse/line-counter.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/parse/line-counter.js
 var require_line_counter = /* @__PURE__ */ __commonJSMin(((exports) => {
 	/**
 	* Tracks newlines during parsing in order to provide an efficient API for
@@ -46901,7 +46953,7 @@ var require_line_counter = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/parse/parser.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/parse/parser.js
 var require_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var node_process = __require$1("process");
 	var cst = require_cst();
@@ -47768,7 +47820,7 @@ var require_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/public-api.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/public-api.js
 var require_public_api = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var composer = require_composer();
 	var Document = require_Document();
@@ -47858,7 +47910,7 @@ var require_public_api = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/index.js
+//#region ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/index.js
 var require_dist = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var composer = require_composer();
 	var Document = require_Document();
@@ -56317,6 +56369,7 @@ var changesets_exports = /* @__PURE__ */ __exportAll({
 	ChangelogTransformer: () => ChangelogTransformer,
 	ChangesetIOError: () => ChangesetIOError,
 	ChangesetLinter: () => ChangesetLinter,
+	ChangesetLogMode: () => ChangesetLogMode,
 	ChangesetOptionsSchema: () => ChangesetOptionsSchema,
 	ChangesetPreviewSchema: () => ChangesetPreviewSchema,
 	ChangesetSchema: () => ChangesetSchema,
@@ -56403,6 +56456,7 @@ var changesets_exports = /* @__PURE__ */ __exportAll({
 	isPureDependencyChangeset: () => isPureDependencyChangeset,
 	listPublishablePackageNames: () => listPublishablePackageNames,
 	makeBranchAnalyzerTest: () => makeBranchAnalyzerTest,
+	makeChangelogFunctions: () => makeChangelogFunctions,
 	makeConfigInspectorTest: () => makeConfigInspectorTest,
 	makeDepsRegenDefault: () => makeDepsRegenDefault,
 	makeGitHubTest: () => makeGitHubTest,