@savvy-web/silk 2.1.1 → 2.1.3

package/changesets-markdownlint.cjs

@@ -1218,7 +1218,7 @@ var YamlToken = class extends effect.Schema.Class("YamlToken")({
 *
 * @public
 */
-function createScanner$1(text) {
+function createScanner$2(text) {
 	let pos = 0;
 	let line = 0;
 	let col = 0;
@@ -2169,7 +2169,7 @@ function createScanner$1(text) {
 * @public
 */
 function lex(text) {
-	return effect.Stream.unfold(createScanner$1(text), (scanner) => {
+	return effect.Stream.unfold(createScanner$2(text), (scanner) => {
 		const kind = scanner.scan();
 		if (kind === null) return effect.Option.none();
 		const token = new YamlToken({
@@ -6313,7 +6313,7 @@ function parseDocument(text, options) {
 *
 * @public
 */
-function parse$2(text, options) {
+function parse$3(text, options) {
 	const uniqueKeys = options?.uniqueKeys ?? true;
 	return parseDocument(text, options).pipe(effect.Effect.flatMap((doc) => {
 		if (uniqueKeys) {
@@ -6335,7 +6335,7 @@ function parse$2(text, options) {
 *
 * @public
 */
-const workspaceManifestFromYaml = (content) => parse$2(content).pipe(effect.Effect.mapError((e) => new CatalogAssemblyError({
+const workspaceManifestFromYaml = (content) => parse$3(content).pipe(effect.Effect.mapError((e) => new CatalogAssemblyError({
 	source: "manifest",
 	reason: `invalid yaml: ${String(e)}`
 })), effect.Effect.map((parsed) => {
@@ -6654,7 +6654,7 @@ var CatalogSet = class CatalogSet extends effect.Schema.Class("CatalogSet")({ en
 *
 * @internal
 */
-const lockfileCatalogsFromText = (text) => parse$2(text).pipe(effect.Effect.map((parsed) => CatalogSet.fromLockfileCatalogs(parsed?.catalogs)), effect.Effect.orElseSucceed(() => CatalogSet.empty()));
+const lockfileCatalogsFromText = (text) => parse$3(text).pipe(effect.Effect.map((parsed) => CatalogSet.fromLockfileCatalogs(parsed?.catalogs)), effect.Effect.orElseSucceed(() => CatalogSet.empty()));
 /**
 * Read the working tree's catalog state at `root`.
 *
@@ -8444,6 +8444,1285 @@ effect.Schema.Class("WorkspaceInfo")({
 	patterns: effect.Schema.Array(effect.Schema.String)
 });
 //#endregion
+//#region ../../node_modules/.pnpm/jsonc-effect@0.3.1_effect@3.21.4/node_modules/jsonc-effect/errors.js
+/**
+* JSONC error types using Effect's Data.TaggedError pattern.
+*
+* @packageDocumentation
+*/
+/**
+* Error codes representing specific JSONC parse failures.
+*
+* @remarks
+* Each code maps to a distinct syntactic error the parser can encounter,
+* from invalid symbols and number formats to missing delimiters and
+* unexpected end-of-input conditions.
+*
+* @see {@link JsoncParseErrorDetail} — carries one of these codes alongside
+*   position information
+*
+* @public
+*/
+const JsoncParseErrorCode = effect.Schema.Literal("InvalidSymbol", "InvalidNumberFormat", "PropertyNameExpected", "ValueExpected", "ColonExpected", "CommaExpected", "CloseBraceExpected", "CloseBracketExpected", "EndOfFileExpected", "InvalidCommentToken", "UnexpectedEndOfComment", "UnexpectedEndOfString", "UnexpectedEndOfNumber", "InvalidUnicode", "InvalidEscapeCharacter", "InvalidCharacter");
+/**
+* Detail for a single parse error, including the error code, a human-readable
+* message, and the exact position within the source document.
+*
+* @remarks
+* - `code` — a {@link (JsoncParseErrorCode:type)} identifying the error kind.
+* - `message` — a descriptive message suitable for display.
+* - `offset` — zero-based character offset where the error occurred.
+* - `length` — character length of the problematic span.
+* - `startLine` — zero-based line number of the error.
+* - `startCharacter` — zero-based column within `startLine`.
+*
+* @see {@link JsoncParseError} — aggregates an array of these details
+*
+* @example
+* ```ts
+* import { JsoncParseErrorDetail } from "jsonc-effect";
+*
+* const detail = new JsoncParseErrorDetail({
+*   code: "ValueExpected",
+*   message: "Value expected",
+*   offset: 5,
+*   length: 1,
+*   startLine: 0,
+*   startCharacter: 5,
+* });
+*
+* console.log(detail.code); // "ValueExpected"
+* console.log(detail.offset); // 5
+* ```
+*
+* @public
+*/
+var JsoncParseErrorDetail = class extends effect.Schema.Class("JsoncParseErrorDetail")({
+	code: JsoncParseErrorCode,
+	message: effect.Schema.String,
+	offset: effect.Schema.Number,
+	length: effect.Schema.Number,
+	startLine: effect.Schema.Number,
+	startCharacter: effect.Schema.Number
+}) {};
+/**
+* Base class for {@link JsoncParseError}; not intended to be constructed or
+* caught directly — use `JsoncParseError` instead.
+*
+* @privateRemarks
+* The `*Base` pattern is required because `Data.TaggedError` produces complex
+* type signatures involving intersection types and branded generics that
+* api-extractor cannot roll up into a single `.d.ts` bundle. Exporting the
+* base separately lets the public `JsoncParseError` class extend it with
+* concrete fields, giving api-extractor a simple class declaration to work
+* with. It is tagged `@public` (rather than `@internal`) because it appears
+* in `JsoncParseError`'s heritage clause in the public `.d.ts`, and API
+* Extractor requires release tags to be compatible across a signature.
+*
+* @public
+*/
+const JsoncParseErrorBase = effect.Data.TaggedError("JsoncParseError");
+/**
+* Error raised when JSONC parsing encounters one or more syntax errors.
+*
+* @remarks
+* Contains the full source `text`, the `options` used for parsing, and an
+* `errors` array of {@link JsoncParseErrorDetail} instances with precise
+* position information for each problem found.
+*
+* @see {@link parse} — may fail with this error
+* @see {@link parseTree} — may fail with this error
+*
+* @example Catching with `Effect.catchTag`
+* ```ts
+* import { Effect } from "effect";
+* import { parse } from "jsonc-effect";
+*
+* const program = parse("{ invalid }").pipe(
+*   Effect.catchTag("JsoncParseError", (e) => {
+*     console.error(e.errors); // Array of JsoncParseErrorDetail
+*     return Effect.succeed({});
+*   }),
+* );
+* ```
+*
+* @example Inspecting error details
+* ```ts
+* import { Effect } from "effect";
+* import { parse } from "jsonc-effect";
+*
+* const program = parse("{ invalid }").pipe(
+*   Effect.catchTag("JsoncParseError", (e) => {
+*     for (const detail of e.errors) {
+*       console.error(
+*         `[${detail.code}] ${detail.message} at line ${detail.startLine}:${detail.startCharacter}`,
+*       );
+*     }
+*     return Effect.succeed({});
+*   }),
+* );
+* ```
+*
+* @public
+*/
+var JsoncParseError = class extends JsoncParseErrorBase {
+	get message() {
+		const count = this.errors.length;
+		return `JSONC parse failed with ${count} error${count !== 1 ? "s" : ""}: ${this.errors.map((e) => e.message).join("; ")}`;
+	}
+};
+effect.Data.TaggedError("JsoncNodeNotFoundError");
+/**
+* Base class for {@link JsoncModificationError}; not intended to be
+* constructed or caught directly — use `JsoncModificationError` instead.
+*
+* @privateRemarks
+* Uses the same `*Base` pattern as {@link JsoncParseErrorBase} to work
+* around api-extractor's inability to roll up the complex type produced
+* by `Data.TaggedError` into a single `.d.ts` declaration. Tagged `@public`
+* for the same heritage-clause-compatibility reason as `JsoncParseErrorBase`.
+*
+* @public
+*/
+const JsoncModificationErrorBase = effect.Data.TaggedError("JsoncModificationError");
+/**
+* Error raised when {@link modify} produces invalid edits or encounters
+* an unsupported modification scenario.
+*
+* @remarks
+* Contains the `path` where modification was attempted and a `reason`
+* string explaining why it failed.
+*
+* @see {@link modify} — may fail with this error
+*
+* @example
+* ```ts
+* import { Effect } from "effect";
+* import { modify } from "jsonc-effect";
+*
+* const program = modify("{}", ["deep", "path"], 42).pipe(
+*   Effect.catchTag("JsoncModificationError", (e) => {
+*     console.error(`Failed at [${e.path.join(", ")}]: ${e.reason}`);
+*     return Effect.succeed([]);
+*   }),
+* );
+* ```
+*
+* @public
+*/
+var JsoncModificationError = class extends JsoncModificationErrorBase {
+	get message() {
+		return `Modification failed at path [${this.path.join(", ")}]: ${this.reason}`;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/jsonc-effect@0.3.1_effect@3.21.4/node_modules/jsonc-effect/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$1 = (ch) => ch >= 48 && ch <= 57;
+/**
+* Create a stateful {@link JsoncScanner} for the given JSONC string.
+*
+* @param text - JSONC string to tokenize
+* @param ignoreTrivia - If `true`, the scanner automatically skips whitespace,
+*   line-break, and comment tokens so that only structural tokens are returned
+*   (default: `false`).
+* @returns A stateful {@link JsoncScanner} positioned before the first token.
+*
+* @remarks
+* When `ignoreTrivia` is `true` the scanner is suitable for building parsers
+* that only care about structural tokens (`OpenBrace`, `String`, `Number`,
+* etc.). Set it to `false` (the default) when you need to preserve comments
+* or whitespace — for example in a formatter or a comment-stripping pass.
+*
+* @see {@link JsoncScanner} — the interface returned by this factory
+* @see {@link parse} — higher-level API that uses a scanner internally
+*
+* @example
+* Tokenizing a JSONC string and printing each token:
+* ```ts
+* import type { JsoncSyntaxKind } from "jsonc-effect";
+* import { createScanner } from "jsonc-effect";
+*
+* const scanner = createScanner('{ "name": "jsonc" }', true);
+* let kind: JsoncSyntaxKind;
+* do {
+*   kind = scanner.scan();
+*   console.log(kind, scanner.getTokenValue());
+* } while (kind !== "EOF");
+* ```
+*
+* @privateRemarks
+* Ported from Microsoft's jsonc-parser (MIT), adapted to use string literal
+* token types instead of numeric enums.
+*
+* @public
+*/
+const createScanner$1 = (text, ignoreTrivia = false) => {
+	const len = text.length;
+	let pos = 0;
+	let tokenOffset = 0;
+	let token = "Unknown";
+	let tokenValue = "";
+	let tokenError = "None";
+	let lineNumber = 0;
+	let lineStartOffset = 0;
+	let tokenStartLine = 0;
+	let tokenStartCharacter = 0;
+	const scanHexDigits = (count) => {
+		let value = 0;
+		for (let i = 0; i < count; i++) {
+			if (pos >= len) return -1;
+			const ch = text.charCodeAt(pos);
+			if (ch >= 48 && ch <= 57) value = value * 16 + (ch - 48);
+			else if (ch >= 65 && ch <= 70) value = value * 16 + (ch - 65 + 10);
+			else if (ch >= 97 && ch <= 102) value = value * 16 + (ch - 97 + 10);
+			else return -1;
+			pos++;
+		}
+		return value;
+	};
+	const scanString = () => {
+		let result = "";
+		pos++;
+		let start = pos;
+		while (pos < len) {
+			const ch = text.charCodeAt(pos);
+			if (ch === 34) {
+				result += text.substring(start, pos);
+				pos++;
+				return result;
+			}
+			if (ch === 92) {
+				result += text.substring(start, pos);
+				pos++;
+				if (pos >= len) {
+					tokenError = "UnexpectedEndOfString";
+					return result;
+				}
+				const escaped = text.charCodeAt(pos);
+				pos++;
+				switch (escaped) {
+					case 34:
+						result += "\"";
+						break;
+					case 92:
+						result += "\\";
+						break;
+					case 47:
+						result += "/";
+						break;
+					case 98:
+						result += "\b";
+						break;
+					case 102:
+						result += "\f";
+						break;
+					case 110:
+						result += "\n";
+						break;
+					case 114:
+						result += "\r";
+						break;
+					case 116:
+						result += "	";
+						break;
+					case 117: {
+						const value = scanHexDigits(4);
+						if (value >= 0) result += String.fromCharCode(value);
+						else tokenError = "InvalidUnicode";
+						break;
+					}
+					default:
+						tokenError = "InvalidEscapeCharacter";
+						break;
+				}
+				start = pos;
+			} else if (isLineBreak$1(ch)) {
+				tokenError = "UnexpectedEndOfString";
+				return result + text.substring(start, pos);
+			} else pos++;
+		}
+		tokenError = "UnexpectedEndOfString";
+		return result + text.substring(start, pos);
+	};
+	const scanNumber = () => {
+		const start = pos;
+		if (text.charCodeAt(pos) === 45) pos++;
+		if (text.charCodeAt(pos) === 48) pos++;
+		else {
+			if (!isDigit$1(text.charCodeAt(pos))) {
+				tokenError = "UnexpectedEndOfNumber";
+				return text.substring(start, pos);
+			}
+			pos++;
+			while (pos < len && isDigit$1(text.charCodeAt(pos))) pos++;
+		}
+		if (pos < len && text.charCodeAt(pos) === 46) {
+			pos++;
+			if (!isDigit$1(text.charCodeAt(pos))) {
+				tokenError = "UnexpectedEndOfNumber";
+				return text.substring(start, 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$1(text.charCodeAt(pos))) {
+				tokenError = "UnexpectedEndOfNumber";
+				return text.substring(start, pos);
+			}
+			pos++;
+			while (pos < len && isDigit$1(text.charCodeAt(pos))) pos++;
+		}
+		return text.substring(start, pos);
+	};
+	const scan = () => {
+		tokenValue = "";
+		tokenError = "None";
+		if (pos >= len) {
+			tokenOffset = len;
+			tokenStartLine = lineNumber;
+			tokenStartCharacter = pos - lineStartOffset;
+			token = "EOF";
+			return token;
+		}
+		let ch = text.charCodeAt(pos);
+		if (isWhitespace(ch)) {
+			tokenOffset = pos;
+			tokenStartLine = lineNumber;
+			tokenStartCharacter = pos - lineStartOffset;
+			do {
+				pos++;
+				ch = pos < len ? text.charCodeAt(pos) : 0;
+			} while (isWhitespace(ch));
+			tokenValue = text.substring(tokenOffset, pos);
+			if (ignoreTrivia) return scan();
+			token = "Trivia";
+			return token;
+		}
+		if (isLineBreak$1(ch)) {
+			tokenOffset = pos;
+			tokenStartLine = lineNumber;
+			tokenStartCharacter = pos - lineStartOffset;
+			pos++;
+			if (ch === 13 && pos < len && text.charCodeAt(pos) === 10) pos++;
+			lineNumber++;
+			lineStartOffset = pos;
+			tokenValue = text.substring(tokenOffset, pos);
+			if (ignoreTrivia) return scan();
+			token = "LineBreak";
+			return token;
+		}
+		tokenOffset = pos;
+		tokenStartLine = lineNumber;
+		tokenStartCharacter = pos - lineStartOffset;
+		switch (ch) {
+			case 123:
+				pos++;
+				tokenValue = "{";
+				token = "OpenBrace";
+				return token;
+			case 125:
+				pos++;
+				tokenValue = "}";
+				token = "CloseBrace";
+				return token;
+			case 91:
+				pos++;
+				tokenValue = "[";
+				token = "OpenBracket";
+				return token;
+			case 93:
+				pos++;
+				tokenValue = "]";
+				token = "CloseBracket";
+				return token;
+			case 58:
+				pos++;
+				tokenValue = ":";
+				token = "Colon";
+				return token;
+			case 44:
+				pos++;
+				tokenValue = ",";
+				token = "Comma";
+				return token;
+			case 34:
+				tokenValue = scanString();
+				token = "String";
+				return token;
+			case 47: {
+				const nextCh = pos + 1 < len ? text.charCodeAt(pos + 1) : 0;
+				if (nextCh === 47) {
+					pos += 2;
+					while (pos < len && !isLineBreak$1(text.charCodeAt(pos))) pos++;
+					tokenValue = text.substring(tokenOffset, pos);
+					if (ignoreTrivia) return scan();
+					token = "LineComment";
+					return token;
+				}
+				if (nextCh === 42) {
+					pos += 2;
+					const safeLen = len - 1;
+					let commentClosed = false;
+					while (pos < safeLen) {
+						const cch = text.charCodeAt(pos);
+						if (isLineBreak$1(cch)) {
+							if (cch === 13 && pos + 1 < len && text.charCodeAt(pos + 1) === 10) pos++;
+							pos++;
+							lineNumber++;
+							lineStartOffset = pos;
+						} else if (cch === 42 && text.charCodeAt(pos + 1) === 47) {
+							pos += 2;
+							commentClosed = true;
+							break;
+						} else pos++;
+					}
+					if (!commentClosed) {
+						pos = len;
+						tokenError = "UnexpectedEndOfComment";
+					}
+					tokenValue = text.substring(tokenOffset, pos);
+					if (ignoreTrivia) return scan();
+					token = "BlockComment";
+					return token;
+				}
+				pos++;
+				tokenValue = text.substring(tokenOffset, pos);
+				token = "Unknown";
+				tokenError = "InvalidCharacter";
+				return token;
+			}
+			case 45:
+				if (pos + 1 < len && isDigit$1(text.charCodeAt(pos + 1))) {
+					tokenValue = scanNumber();
+					token = "Number";
+					return token;
+				}
+				pos++;
+				tokenValue = "-";
+				token = "Unknown";
+				tokenError = "InvalidSymbol";
+				return token;
+			default:
+				if (isDigit$1(ch)) {
+					tokenValue = scanNumber();
+					token = "Number";
+					return token;
+				}
+				if (ch >= 97 && ch <= 122) {
+					const start = pos;
+					pos++;
+					while (pos < len) {
+						const kch = text.charCodeAt(pos);
+						if (kch >= 97 && kch <= 122) pos++;
+						else break;
+					}
+					tokenValue = text.substring(start, pos);
+					switch (tokenValue) {
+						case "true":
+							token = "True";
+							return token;
+						case "false":
+							token = "False";
+							return token;
+						case "null":
+							token = "Null";
+							return token;
+						default:
+							token = "Unknown";
+							tokenError = "InvalidSymbol";
+							return token;
+					}
+				}
+				pos++;
+				tokenValue = text.substring(tokenOffset, pos);
+				token = "Unknown";
+				tokenError = "InvalidCharacter";
+				return token;
+		}
+	};
+	return {
+		scan,
+		getToken: () => token,
+		getTokenValue: () => tokenValue,
+		getTokenOffset: () => tokenOffset,
+		getTokenLength: () => pos - tokenOffset,
+		getTokenStartLine: () => tokenStartLine,
+		getTokenStartCharacter: () => tokenStartCharacter,
+		getTokenError: () => tokenError,
+		getPosition: () => pos,
+		setPosition: (newPos) => {
+			pos = newPos;
+			tokenValue = "";
+			token = "Unknown";
+			tokenError = "None";
+		}
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/jsonc-effect@0.3.1_effect@3.21.4/node_modules/jsonc-effect/parse.js
+/**
+* JSONC Parser — converts token stream into JavaScript values or AST nodes.
+*
+* Pure Effect implementation using recursive descent parsing.
+* Reference: Microsoft's jsonc-parser parser design (MIT).
+*
+* @packageDocumentation
+*/
+/**
+* Parse a JSONC string into a JavaScript value.
+*
+* @param text - JSONC string to parse
+* @param options - Optional {@link JsoncParseOptions} controlling comment and
+*   trailing-comma handling.
+* @returns `Effect<unknown, JsoncParseError>` — succeeds with the parsed value
+*   or fails with a {@link JsoncParseError} containing every error encountered.
+*
+* @remarks
+* The return type is `unknown` (not `any`) so consumers are forced to narrow
+* the result, which is safer in Effect pipelines. By default
+* `allowTrailingComma` is `true`, matching common JSONC conventions used in
+* VS Code settings and `tsconfig.json`.
+*
+* @see {@link parseTree} — parse into an AST instead of a plain value
+* @see {@link JsoncParseOptions} — available parse options
+* @see {@link JsoncParseError} — the tagged error type on the failure channel
+*
+* @example
+* Basic parsing:
+* ```ts
+* import { Effect } from "effect";
+* import { parse } from "jsonc-effect";
+*
+* const value = Effect.runSync(parse('{ "key": 42 }'));
+* console.log(value); // { key: 42 }
+* ```
+*
+* @example
+* Parsing with options:
+* ```ts
+* import { Effect } from "effect";
+* import { parse } from "jsonc-effect";
+*
+* const value = Effect.runSync(
+*   parse('{ "key": 42 }', { disallowComments: true }),
+* );
+* ```
+*
+* @example
+* Error handling with `catchTag`:
+* ```ts
+* import { Effect } from "effect";
+* import { parse } from "jsonc-effect";
+*
+* const program = parse("{ bad }").pipe(
+*   Effect.catchTag("JsoncParseError", (err) =>
+*     Effect.succeed({ fallback: true, errors: err.errors }),
+*   ),
+* );
+*
+* const result = Effect.runSync(program);
+* console.log(result);
+* ```
+*
+* @example
+* Using `Effect.gen`:
+* ```ts
+* import { Effect } from "effect";
+* import { parse } from "jsonc-effect";
+*
+* const program = Effect.gen(function* () {
+*   const config = yield* parse('{ "port": 3000 }');
+*   return config;
+* });
+*
+* const result = Effect.runSync(program);
+* console.log(result); // { port: 3000 }
+* ```
+*
+* @privateRemarks
+* Uses {@link createScanner} internally with a recursive descent parser.
+* The scanner is created with `ignoreTrivia = false` so the parser can
+* report comment-related errors when `disallowComments` is set.
+*
+* @public
+*/
+const parse$2 = (text, options) => effect.Effect.sync(() => parseInternal(text, options ?? {}, false)).pipe(effect.Effect.flatMap(({ value, errors }) => {
+	if (errors.length > 0) return effect.Effect.fail(new JsoncParseError({
+		errors,
+		text,
+		...options !== void 0 ? { options } : {}
+	}));
+	return effect.Effect.succeed(value);
+}));
+function parseInternal(text, options, buildTree) {
+	const scanner = createScanner$1(text, false);
+	const errors = [];
+	const disallowComments = options.disallowComments ?? false;
+	const allowTrailingComma = options.allowTrailingComma ?? true;
+	const allowEmptyContent = options.allowEmptyContent ?? false;
+	let currentToken = "Unknown";
+	function token() {
+		return currentToken;
+	}
+	function scanNext() {
+		for (;;) {
+			currentToken = scanner.scan();
+			switch (scanner.getTokenError()) {
+				case "InvalidUnicode":
+					handleError("InvalidUnicode");
+					break;
+				case "InvalidEscapeCharacter":
+					handleError("InvalidEscapeCharacter");
+					break;
+				case "UnexpectedEndOfNumber":
+					handleError("InvalidNumberFormat");
+					break;
+				case "UnexpectedEndOfComment":
+					handleError("UnexpectedEndOfComment");
+					break;
+				case "UnexpectedEndOfString":
+					handleError("UnexpectedEndOfString");
+					break;
+				case "InvalidCharacter":
+					handleError("InvalidCharacter");
+					break;
+			}
+			switch (currentToken) {
+				case "LineComment":
+				case "BlockComment":
+					if (disallowComments) handleError("InvalidCommentToken");
+					break;
+				case "Trivia":
+				case "LineBreak": break;
+				default: return currentToken;
+			}
+		}
+	}
+	function tokenEnd() {
+		return scanner.getTokenOffset() + scanner.getTokenLength();
+	}
+	function handleError(code, skipUntilAfter = [], skipUntil = []) {
+		errors.push(new JsoncParseErrorDetail({
+			code,
+			message: formatError(code, scanner.getTokenOffset()),
+			offset: scanner.getTokenOffset(),
+			length: scanner.getTokenLength(),
+			startLine: scanner.getTokenStartLine(),
+			startCharacter: scanner.getTokenStartCharacter()
+		}));
+		if (skipUntilAfter.length > 0 || skipUntil.length > 0) {
+			let t = token();
+			while (t !== "EOF") {
+				if (skipUntilAfter.includes(t)) {
+					scanNext();
+					break;
+				}
+				if (skipUntil.includes(t)) break;
+				t = scanNext();
+			}
+		}
+	}
+	function parseValue() {
+		switch (token()) {
+			case "OpenBracket": return parseArray();
+			case "OpenBrace": return parseObject();
+			case "String": return parseString();
+			case "Number": return parseNumber();
+			case "True":
+				scanNext();
+				return true;
+			case "False":
+				scanNext();
+				return false;
+			case "Null":
+				scanNext();
+				return null;
+			default: return;
+		}
+	}
+	function parseString() {
+		const value = scanner.getTokenValue();
+		scanNext();
+		return value;
+	}
+	function parseNumber() {
+		const value = Number.parseFloat(scanner.getTokenValue());
+		scanNext();
+		return value;
+	}
+	function parseArray() {
+		scanNext();
+		const arr = [];
+		let needsComma = false;
+		while (token() !== "CloseBracket" && token() !== "EOF") {
+			if (token() === "Comma") {
+				if (!needsComma) handleError("ValueExpected");
+				scanNext();
+				if (token() === "CloseBracket" && allowTrailingComma) break;
+			} else if (needsComma) handleError("CommaExpected");
+			const value = parseValue();
+			if (value === void 0) handleError("ValueExpected", [], ["CloseBracket", "Comma"]);
+			else arr.push(value);
+			needsComma = true;
+		}
+		if (token() !== "CloseBracket") handleError("CloseBracketExpected");
+		else scanNext();
+		return arr;
+	}
+	function parseObject() {
+		scanNext();
+		const obj = {};
+		let needsComma = false;
+		while (token() !== "CloseBrace" && token() !== "EOF") {
+			if (token() === "Comma") {
+				if (!needsComma) handleError("PropertyNameExpected");
+				scanNext();
+				if (token() === "CloseBrace" && allowTrailingComma) break;
+			} else if (needsComma) handleError("CommaExpected");
+			if (token() !== "String") {
+				handleError("PropertyNameExpected", [], ["CloseBrace", "Comma"]);
+				continue;
+			}
+			const key = scanner.getTokenValue();
+			scanNext();
+			if (token() !== "Colon") {
+				handleError("ColonExpected", [], ["CloseBrace", "Comma"]);
+				continue;
+			}
+			scanNext();
+			const value = parseValue();
+			if (value === void 0) handleError("ValueExpected", [], ["CloseBrace", "Comma"]);
+			else obj[key] = value;
+			needsComma = true;
+		}
+		if (token() !== "CloseBrace") handleError("CloseBraceExpected");
+		else scanNext();
+		return obj;
+	}
+	function parseValueTree() {
+		switch (token()) {
+			case "OpenBracket": return parseArrayTree();
+			case "OpenBrace": return parseObjectTree();
+			case "String": {
+				const node = {
+					type: "string",
+					offset: scanner.getTokenOffset(),
+					length: 0,
+					value: scanner.getTokenValue()
+				};
+				const end = tokenEnd();
+				scanNext();
+				node.length = end - node.offset;
+				return node;
+			}
+			case "Number": {
+				const node = {
+					type: "number",
+					offset: scanner.getTokenOffset(),
+					length: 0,
+					value: Number.parseFloat(scanner.getTokenValue())
+				};
+				const end = tokenEnd();
+				scanNext();
+				node.length = end - node.offset;
+				return node;
+			}
+			case "True": {
+				const node = {
+					type: "boolean",
+					offset: scanner.getTokenOffset(),
+					length: 0,
+					value: true
+				};
+				const end = tokenEnd();
+				scanNext();
+				node.length = end - node.offset;
+				return node;
+			}
+			case "False": {
+				const node = {
+					type: "boolean",
+					offset: scanner.getTokenOffset(),
+					length: 0,
+					value: false
+				};
+				const end = tokenEnd();
+				scanNext();
+				node.length = end - node.offset;
+				return node;
+			}
+			case "Null": {
+				const node = {
+					type: "null",
+					offset: scanner.getTokenOffset(),
+					length: 0,
+					value: null
+				};
+				const end = tokenEnd();
+				scanNext();
+				node.length = end - node.offset;
+				return node;
+			}
+			default: return;
+		}
+	}
+	function parseArrayTree() {
+		const node = {
+			type: "array",
+			offset: scanner.getTokenOffset(),
+			length: 0,
+			children: []
+		};
+		scanNext();
+		let needsComma = false;
+		while (token() !== "CloseBracket" && token() !== "EOF") {
+			if (token() === "Comma") {
+				if (!needsComma) handleError("ValueExpected");
+				scanNext();
+				if (token() === "CloseBracket" && allowTrailingComma) break;
+			} else if (needsComma) handleError("CommaExpected");
+			const child = parseValueTree();
+			if (child) node.children.push(child);
+			else handleError("ValueExpected", [], ["CloseBracket", "Comma"]);
+			needsComma = true;
+		}
+		let end;
+		if (token() !== "CloseBracket") {
+			handleError("CloseBracketExpected");
+			end = scanner.getTokenOffset();
+		} else {
+			end = tokenEnd();
+			scanNext();
+		}
+		node.length = end - node.offset;
+		return node;
+	}
+	function parseObjectTree() {
+		const node = {
+			type: "object",
+			offset: scanner.getTokenOffset(),
+			length: 0,
+			children: []
+		};
+		scanNext();
+		let needsComma = false;
+		while (token() !== "CloseBrace" && token() !== "EOF") {
+			if (token() === "Comma") {
+				if (!needsComma) handleError("PropertyNameExpected");
+				scanNext();
+				if (token() === "CloseBrace" && allowTrailingComma) break;
+			} else if (needsComma) handleError("CommaExpected");
+			if (token() !== "String") {
+				handleError("PropertyNameExpected", [], ["CloseBrace", "Comma"]);
+				continue;
+			}
+			const property = {
+				type: "property",
+				offset: scanner.getTokenOffset(),
+				length: 0,
+				children: []
+			};
+			const keyNode = {
+				type: "string",
+				offset: scanner.getTokenOffset(),
+				length: 0,
+				value: scanner.getTokenValue()
+			};
+			const keyEnd = tokenEnd();
+			scanNext();
+			keyNode.length = keyEnd - keyNode.offset;
+			property.children.push(keyNode);
+			if (token() !== "Colon") {
+				handleError("ColonExpected", [], ["CloseBrace", "Comma"]);
+				property.length = scanner.getTokenOffset() - property.offset;
+				node.children.push(property);
+				continue;
+			}
+			property.colonOffset = scanner.getTokenOffset();
+			scanNext();
+			const valueNode = parseValueTree();
+			if (valueNode) {
+				property.children.push(valueNode);
+				property.length = valueNode.offset + valueNode.length - property.offset;
+			} else {
+				handleError("ValueExpected", [], ["CloseBrace", "Comma"]);
+				property.length = scanner.getTokenOffset() - property.offset;
+			}
+			node.children.push(property);
+			needsComma = true;
+		}
+		let end;
+		if (token() !== "CloseBrace") {
+			handleError("CloseBraceExpected");
+			end = scanner.getTokenOffset();
+		} else {
+			end = tokenEnd();
+			scanNext();
+		}
+		node.length = end - node.offset;
+		return node;
+	}
+	scanNext();
+	if (buildTree) {
+		const root = parseValueTree();
+		if (token() !== "EOF") handleError("EndOfFileExpected");
+		if (!root && !allowEmptyContent) handleError("ValueExpected");
+		return {
+			value: void 0,
+			root,
+			errors
+		};
+	}
+	const value = parseValue();
+	if (token() !== "EOF") handleError("EndOfFileExpected");
+	if (value === void 0 && !allowEmptyContent) handleError("ValueExpected");
+	return {
+		value,
+		root: void 0,
+		errors
+	};
+}
+function formatError(code, offset) {
+	switch (code) {
+		case "InvalidSymbol": return `Invalid symbol at offset ${offset}`;
+		case "InvalidNumberFormat": return `Invalid number format at offset ${offset}`;
+		case "PropertyNameExpected": return `Property name expected at offset ${offset}`;
+		case "ValueExpected": return `Value expected at offset ${offset}`;
+		case "ColonExpected": return `Colon expected at offset ${offset}`;
+		case "CommaExpected": return `Comma expected at offset ${offset}`;
+		case "CloseBraceExpected": return `Close brace expected at offset ${offset}`;
+		case "CloseBracketExpected": return `Close bracket expected at offset ${offset}`;
+		case "EndOfFileExpected": return `End of file expected at offset ${offset}`;
+		case "InvalidCommentToken": return `Comments not allowed at offset ${offset}`;
+		case "UnexpectedEndOfComment": return `Unexpected end of comment at offset ${offset}`;
+		case "UnexpectedEndOfString": return `Unexpected end of string at offset ${offset}`;
+		case "UnexpectedEndOfNumber": return `Unexpected end of number at offset ${offset}`;
+		case "InvalidUnicode": return `Invalid unicode escape at offset ${offset}`;
+		case "InvalidEscapeCharacter": return `Invalid escape character at offset ${offset}`;
+		case "InvalidCharacter": return `Invalid character at offset ${offset}`;
+		default: return `Parse error at offset ${offset}`;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/jsonc-effect@0.3.1_effect@3.21.4/node_modules/jsonc-effect/format.js
+/**
+* Apply an array of text edits to JSONC source text.
+*
+* This is a {@link https://effect.website/docs/function-dual | Function.dual}
+* that supports both data-first and data-last (pipeline) usage.
+*
+* @param text - The original JSONC source text.
+* @param edits - A read-only array of {@link JsoncEdit} objects, typically
+*   produced by {@link format} or {@link modify}.
+* @returns An `Effect` that succeeds with the edited string.
+*
+* @remarks
+* Edits are sorted in reverse offset order before application so that
+* earlier edits do not shift the offsets of later ones. The original `edits`
+* array is not mutated.
+*
+* @see {@link format} to compute formatting edits.
+* @see {@link modify} to compute structural edits (insert, replace, remove).
+*
+* @example Data-first usage
+* ```ts
+* import { Effect } from "effect";
+* import { format, applyEdits } from "jsonc-effect";
+*
+* const input = '{"a":1}';
+* const edits = Effect.runSync(format(input));
+* const result: string = Effect.runSync(applyEdits(input, edits));
+* ```
+*
+* @example Pipeline with modify
+* ```ts
+* import { Effect, pipe } from "effect";
+* import { modify, applyEdits } from "jsonc-effect";
+*
+* const input = '{ "a": 1 }';
+* const result = pipe(
+*   input,
+*   modify(["a"], 42),
+*   Effect.flatMap((edits) => applyEdits(input, edits)),
+*   Effect.runSync,
+* );
+* ```
+*
+* @public
+*/
+const applyEdits$1 = effect.Function.dual(2, (text, edits) => effect.Effect.sync(() => {
+	const sorted = [...edits].sort((a, b) => b.offset - a.offset);
+	let result = text;
+	for (const edit of sorted) result = result.substring(0, edit.offset) + edit.content + result.substring(edit.offset + edit.length);
+	return result;
+}));
+/**
+* Compute edits to insert, replace, or remove a value at a JSON path.
+*
+* This is a {@link https://effect.website/docs/function-dual | Function.dual}
+* that supports both data-first and data-last (pipeline) usage.
+*
+* @param text - The JSONC source text to modify.
+* @param path - A {@link (JsoncPath:type)} (array of string keys and numeric indices)
+*   identifying the target location in the JSON structure.
+* @param value - The value to set. Pass `undefined` to remove the
+*   property or array element at the given path.
+* @param options - Optional object with `formattingOptions` controlling
+*   indent size, tabs vs. spaces, and EOL style for generated text.
+* @returns An `Effect` that succeeds with a read-only array of
+*   {@link JsoncEdit} objects, or fails with a
+*   {@link JsoncModificationError} if the path cannot be navigated.
+*
+* @remarks
+* Setting `value` to `undefined` removes the targeted property or element,
+* including its surrounding comma. When inserting a new property into an
+* object, it is appended after the last existing property.
+*
+* @see {@link applyEdits} to apply the returned edits to the source text.
+* @see {@link JsoncModificationError} for the error type on navigation failure.
+*
+* @example Update an existing property
+* ```ts
+* import { Effect } from "effect";
+* import { modify, applyEdits } from "jsonc-effect";
+*
+* const input = '{ "a": 1 }';
+* const edits = Effect.runSync(modify(input, ["a"], 2));
+* const result: string = Effect.runSync(applyEdits(input, edits));
+* ```
+*
+* @example Insert a new property
+* ```ts
+* import { Effect } from "effect";
+* import { modify, applyEdits } from "jsonc-effect";
+*
+* const input = '{ "a": 1 }';
+* const edits = Effect.runSync(modify(input, ["b"], "hello"));
+* const result: string = Effect.runSync(applyEdits(input, edits));
+* ```
+*
+* @example Remove a property
+* ```ts
+* import { Effect } from "effect";
+* import { modify, applyEdits } from "jsonc-effect";
+*
+* const input = '{ "a": 1, "b": 2 }';
+* const edits = Effect.runSync(modify(input, ["a"], undefined));
+* const result: string = Effect.runSync(applyEdits(input, edits));
+* ```
+*
+* @example Pipeline (data-last) usage
+* ```ts
+* import { Effect, pipe } from "effect";
+* import { modify, applyEdits } from "jsonc-effect";
+*
+* const input = '{ "a": 1 }';
+* const result = pipe(
+*   input,
+*   modify(["a"], 42),
+*   Effect.flatMap((edits) => applyEdits(input, edits)),
+*   Effect.runSync,
+* );
+* ```
+*
+* @privateRemarks
+* Uses its own scanner-based navigation to locate the target path rather
+* than building a full AST via `parseTree`. This keeps the implementation
+* lightweight and avoids an intermediate allocation.
+*
+* @public
+*/
+const modify = effect.Function.dual((args) => typeof args[0] === "string" && Array.isArray(args[1]), (text, path, value, options) => effect.Effect.try({
+	try: () => modifyImpl(text, path, value, options?.formattingOptions),
+	catch: (e) => new JsoncModificationError({
+		path,
+		reason: String(e)
+	})
+}));
+function modifyImpl(text, path, value, formattingOptions) {
+	const opts = {
+		tabSize: formattingOptions?.tabSize ?? 2,
+		insertSpaces: formattingOptions?.insertSpaces ?? true,
+		eol: formattingOptions?.eol ?? "\n"
+	};
+	const indentUnit = opts.insertSpaces ? " ".repeat(opts.tabSize) : "	";
+	if (path.length === 0) {
+		const content = value === void 0 ? "" : JSON.stringify(value, null, opts.tabSize);
+		return [{
+			offset: 0,
+			length: text.length,
+			content
+		}];
+	}
+	const scanner = createScanner$1(text, true);
+	let currentToken = scanner.scan();
+	function tokenEnd() {
+		return scanner.getTokenOffset() + scanner.getTokenLength();
+	}
+	function skipValue() {
+		switch (currentToken) {
+			case "OpenBrace": {
+				let end = tokenEnd();
+				currentToken = scanner.scan();
+				let first = true;
+				while (currentToken !== "CloseBrace" && currentToken !== "EOF") {
+					if (!first && currentToken === "Comma") currentToken = scanner.scan();
+					if (currentToken === "String") {
+						currentToken = scanner.scan();
+						if (currentToken === "Colon") {
+							currentToken = scanner.scan();
+							end = skipValue();
+						}
+					} else {
+						end = tokenEnd();
+						currentToken = scanner.scan();
+					}
+					first = false;
+				}
+				if (currentToken === "CloseBrace") {
+					end = tokenEnd();
+					currentToken = scanner.scan();
+				}
+				return end;
+			}
+			case "OpenBracket": {
+				let end = tokenEnd();
+				currentToken = scanner.scan();
+				let first = true;
+				while (currentToken !== "CloseBracket" && currentToken !== "EOF") {
+					if (!first && currentToken === "Comma") currentToken = scanner.scan();
+					end = skipValue();
+					first = false;
+				}
+				if (currentToken === "CloseBracket") {
+					end = tokenEnd();
+					currentToken = scanner.scan();
+				}
+				return end;
+			}
+			default: {
+				const end = tokenEnd();
+				currentToken = scanner.scan();
+				return end;
+			}
+		}
+	}
+	let depth = 0;
+	for (const segment of path) {
+		depth++;
+		if (typeof segment === "string") {
+			if (currentToken !== "OpenBrace") throw new Error(`Expected object at depth ${depth}`);
+			currentToken = scanner.scan();
+			let found = false;
+			let lastValueEnd = scanner.getTokenOffset();
+			let isFirst = true;
+			while (currentToken !== "CloseBrace" && currentToken !== "EOF") {
+				if (!isFirst && currentToken === "Comma") currentToken = scanner.scan();
+				if (currentToken === "String") {
+					const key = scanner.getTokenValue();
+					currentToken = scanner.scan();
+					if (currentToken === "Colon") currentToken = scanner.scan();
+					if (key === segment) {
+						found = true;
+						if (depth === path.length) {
+							const valueStart = scanner.getTokenOffset();
+							const prevEnd = valueStart;
+							const valueEnd = skipValue();
+							if (value === void 0) {
+								let removeStart = valueStart;
+								let removeEnd = valueEnd;
+								const keyStart = text.substring(0, valueStart).lastIndexOf(`"${segment}"`);
+								if (keyStart >= 0) removeStart = keyStart;
+								const commaPosBefore = text.substring(0, removeStart).trimEnd().lastIndexOf(",");
+								if (commaPosBefore >= 0) removeStart = commaPosBefore;
+								else {
+									const trimmedAfter = text.substring(removeEnd).match(/^(\s*,)/);
+									if (trimmedAfter) removeEnd += trimmedAfter[1].length;
+								}
+								return [{
+									offset: removeStart,
+									length: removeEnd - removeStart,
+									content: ""
+								}];
+							}
+							const serialized = JSON.stringify(value, null, opts.tabSize);
+							return [{
+								offset: prevEnd,
+								length: valueEnd - prevEnd,
+								content: serialized
+							}];
+						}
+						break;
+					}
+					lastValueEnd = skipValue();
+				} else {
+					currentToken = scanner.scan();
+					lastValueEnd = scanner.getTokenOffset();
+				}
+				isFirst = false;
+			}
+			if (!found && depth === path.length && value !== void 0) {
+				const indent = indentUnit.repeat(depth);
+				const serialized = JSON.stringify(value, null, opts.tabSize);
+				const insertText = isFirst ? `${opts.eol}${indent}"${segment}": ${serialized}${opts.eol}${indentUnit.repeat(depth - 1)}` : `,${opts.eol}${indent}"${segment}": ${serialized}`;
+				return [{
+					offset: lastValueEnd,
+					length: 0,
+					content: insertText
+				}];
+			}
+		} else {
+			if (currentToken !== "OpenBracket") throw new Error(`Expected array at depth ${depth}`);
+			currentToken = scanner.scan();
+			let idx = 0;
+			let lastEnd = scanner.getTokenOffset();
+			while (currentToken !== "CloseBracket" && currentToken !== "EOF") {
+				if (idx > 0 && currentToken === "Comma") currentToken = scanner.scan();
+				if (idx === segment) {
+					if (depth === path.length) {
+						const valueStart = scanner.getTokenOffset();
+						const valueEnd = skipValue();
+						if (value === void 0) {
+							let removeEnd = valueEnd;
+							if (text.substring(removeEnd).trimStart().startsWith(",")) removeEnd = text.indexOf(",", removeEnd) + 1;
+							return [{
+								offset: valueStart,
+								length: removeEnd - valueStart,
+								content: ""
+							}];
+						}
+						const serialized = JSON.stringify(value, null, opts.tabSize);
+						return [{
+							offset: valueStart,
+							length: valueEnd - valueStart,
+							content: serialized
+						}];
+					}
+					break;
+				}
+				lastEnd = skipValue();
+				idx++;
+			}
+			if (idx <= segment && depth === path.length && value !== void 0) {
+				const indent = indentUnit.repeat(depth);
+				const serialized = JSON.stringify(value, null, opts.tabSize);
+				const insertText = idx === 0 ? `${opts.eol}${indent}${serialized}${opts.eol}${indentUnit.repeat(depth - 1)}` : `,${opts.eol}${indent}${serialized}`;
+				return [{
+					offset: lastEnd,
+					length: 0,
+					content: insertText
+				}];
+			}
+		}
+	}
+	return [];
+}
+//#endregion
 //#region ../../node_modules/.pnpm/workspaces-effect@2.0.2_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/schemas/WorkspaceStateSnapshot.js
 const DepRecord = effect.Schema.optionalWith(effect.Schema.Record({
 	key: effect.Schema.String,
@@ -8730,7 +10009,7 @@ const packageSnapshotFromJson = (text, relativePath) => {
 *
 * @internal
 */
-const lockfileCatalogsAtRef = (text) => effect.Option.isNone(text) ? effect.Effect.succeed(CatalogSet.empty()) : parse$2(text.value).pipe(effect.Effect.map((parsed) => CatalogSet.fromLockfileCatalogs(parsed?.catalogs)), effect.Effect.orElseSucceed(() => CatalogSet.empty()));
+const lockfileCatalogsAtRef = (text) => effect.Option.isNone(text) ? effect.Effect.succeed(CatalogSet.empty()) : parse$3(text.value).pipe(effect.Effect.map((parsed) => CatalogSet.fromLockfileCatalogs(parsed?.catalogs)), effect.Effect.orElseSucceed(() => CatalogSet.empty()));
 /**
 * Live layer for the {@link PointInTimeWorkspace} service.
 *
@@ -37463,15 +38742,16 @@ function makeShape$2(inspector) {
 			path,
 			status: "added"
 		}));
+		const isOwnChangeset = (path) => path.startsWith(".changeset/") && path.endsWith(".md");
 		const seen = /* @__PURE__ */ new Set();
 		const rawEntries = [];
 		for (const e of diffEntries) {
-			if (seen.has(e.path)) continue;
+			if (seen.has(e.path) || isOwnChangeset(e.path)) continue;
 			seen.add(e.path);
 			rawEntries.push(e);
 		}
 		for (const e of untrackedEntries) {
-			if (seen.has(e.path)) continue;
+			if (seen.has(e.path) || isOwnChangeset(e.path)) continue;
 			seen.add(e.path);
 			rawEntries.push(e);
 		}
@@ -37604,6 +38884,32 @@ const DEP_TYPE_MAP = [
 */
 const resolveOrRaw = (snapshot, dep, spec) => effect.Option.getOrElse(snapshot.resolve(dep, spec), () => spec);
 /**
+* Drop no-net-change field moves: the same dependency removed from one field
+* and added to another with an equal resolved version (e.g. a dep promoted
+* from `devDependencies` to `dependencies`). A field reclassification is a
+* contract change worth release-note prose, not a version movement, so it
+* must not surface as an unrelated removed row plus an added row. Moves that
+* also change the resolved version keep both rows (the movement is real).
+*/
+const collapseFieldMoves = (rows) => {
+	const dropped = /* @__PURE__ */ new Set();
+	const byName = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const group = byName.get(row.dependency);
+		if (group) group.push(row);
+		else byName.set(row.dependency, [row]);
+	}
+	for (const group of byName.values()) for (const removed of group) {
+		if (removed.action !== "removed" || dropped.has(removed)) continue;
+		const added = group.find((r) => r.action === "added" && !dropped.has(r) && r.type !== removed.type && r.to === removed.from);
+		if (added) {
+			dropped.add(removed);
+			dropped.add(added);
+		}
+	}
+	return rows.filter((r) => !dropped.has(r));
+};
+/**
 * Diff two workspace snapshots and return per-package dependency-table rows,
 * comparing already-resolved specifier values per side.
 *
@@ -37659,10 +38965,11 @@ function computeWorkspaceDependencyDiffs(before, after) {
 				});
 			}
 		}
-		if (rows.length > 0) result.push({
+		const collapsed = collapseFieldMoves(rows);
+		if (collapsed.length > 0) result.push({
 			package: afterPkg.name,
 			relativePath: afterPkg.relativePath,
-			rows: sortDependencyRows(rows)
+			rows: sortDependencyRows(collapsed)
 		});
 	}
 	return result;
@@ -38002,7 +39309,8 @@ function makeShape$1(pit, inspector, discovery, detector, config, fs) {
 			fromRef = yield* gitMergeBase(resolvedCwd, baseBranch);
 		}
 		const rawDiffs = computeWorkspaceDependencyDiffs(yield* pit.at(fromRef, { cwd: resolvedCwd }), options.to ? yield* pit.at(options.to, { cwd: resolvedCwd }) : yield* pit.worktree({ cwd: resolvedCwd }));
-		const targetPkg = options.package;
+		const explicitTargets = /* @__PURE__ */ new Set([...options.packages ?? [], ...options.package ? [options.package] : []]);
+		const excluded = new Set(options.exclude ?? []);
 		const livePackages = yield* discovery.listPackages(resolvedCwd);
 		const publishable = yield* listPublishablePackageNames(livePackages, resolvedCwd).pipe(effect.Effect.provide(provideDetector));
 		const versionPrivate = yield* config.versionPrivate(resolvedCwd);
@@ -38011,9 +39319,15 @@ function makeShape$1(pit, inspector, discovery, detector, config, fs) {
 			if (yield* config.isIgnored(pkg.name, resolvedCwd)) continue;
 			if (publishable.has(pkg.name) || versionPrivate) inScope.add(pkg.name);
 		}
-		const targetIgnored = targetPkg ? yield* config.isIgnored(targetPkg, resolvedCwd) : false;
+		const activeTargets = /* @__PURE__ */ new Set();
+		for (const name of explicitTargets) {
+			if (excluded.has(name)) continue;
+			if (yield* config.isIgnored(name, resolvedCwd)) continue;
+			activeTargets.add(name);
+		}
+		const inScopeFor = (name) => explicitTargets.size > 0 ? activeTargets.has(name) : inScope.has(name) && !excluded.has(name);
 		const keepDevDeps = options.includeDevDeps === true;
-		const scoped = targetPkg ? targetIgnored ? [] : rawDiffs.filter((d) => d.package === targetPkg) : rawDiffs.filter((d) => inScope.has(d.package));
+		const scoped = rawDiffs.filter((d) => inScopeFor(d.package));
 		const resolved = [];
 		for (const diff of scoped) {
 			const rows = keepDevDeps ? [...diff.rows] : diff.rows.filter((r) => r.type !== "devDependency");
@@ -38024,7 +39338,7 @@ function makeShape$1(pit, inspector, discovery, detector, config, fs) {
 		}
 		const existingPure = yield* findPureDependencyChangesets(fs, changesetDir);
 		const skippedMixed = yield* findMixedDependencyChangesets(fs, changesetDir);
-		const toDelete = targetPkg ? targetIgnored ? [] : existingPure.filter((p) => p.package === targetPkg) : existingPure.filter((p) => inScope.has(p.package));
+		const toDelete = existingPure.filter((p) => inScopeFor(p.package));
 		const chosenFilenames = /* @__PURE__ */ new Set();
 		const toWrite = [];
 		for (const diff of resolved) {
@@ -38240,23 +39554,46 @@ function parseJsonPath(path) {
 * @internal
 */
 function jsonPathGet(obj, path) {
+	return walkJsonPath(obj, path).map((entry) => entry.node);
+}
+/**
+* Shared breadth-first traversal behind {@link jsonPathGet} and
+* {@link jsonPathResolve}: each segment fans out the current set of matched
+* entries, carrying both the node and the concrete path taken to reach it.
+* The two public functions differ only in which half of the entry they keep.
+*/
+function walkJsonPath(obj, path) {
 	const segments = parseJsonPath(path);
-	let current = [obj];
+	let current = [{
+		node: obj,
+		path: []
+	}];
 	for (const segment of segments) {
 		const next = [];
-		for (const node of current) {
+		for (const { node, path: nodePath } of current) {
 			if (node === null || node === void 0 || typeof node !== "object") continue;
 			switch (segment.type) {
 				case "property": {
 					const value = node[segment.key];
-					if (value !== void 0) next.push(value);
+					if (value !== void 0) next.push({
+						node: value,
+						path: [...nodePath, segment.key]
+					});
 					break;
 				}
 				case "index":
-					if (Array.isArray(node) && segment.index < node.length) next.push(node[segment.index]);
+					if (Array.isArray(node) && segment.index < node.length) next.push({
+						node: node[segment.index],
+						path: [...nodePath, segment.index]
+					});
 					break;
 				case "wildcard":
-					if (Array.isArray(node)) next.push(...node);
+					if (Array.isArray(node)) node.forEach((element, index) => {
+						next.push({
+							node: element,
+							path: [...nodePath, index]
+						});
+					});
 					break;
 			}
 		}
@@ -38265,81 +39602,37 @@ function jsonPathGet(obj, path) {
 	return current;
 }
 /**
-* Mutate all matching locations in an object in-place.
+* Resolve a JSONPath expression to the concrete paths of every existing match.
 *
 * @remarks
-* Walks to the parent(s) of the final segment, then sets the value
-* at each matching location. Only updates existing keys/indices;
-* does not create new properties or extend arrays. Returns the count
-* of locations actually updated.
+* Uses the same breadth-first expansion as {@link jsonPathGet}, but instead of
+* collecting the matched *values* it records the concrete `(string | number)[]`
+* path taken to reach each one. Wildcards and indices are materialized into the
+* numeric array index actually traversed, so the returned paths are directly
+* consumable by structural editors such as `jsonc-effect`'s `modify`, which
+* require a fully concrete path (no wildcards).
 *
-* @param obj - The object to modify in-place
+* Only existing locations are returned; nothing is created. A path with no
+* matches yields an empty array, and the empty path (`"$."`) yields a single
+* empty concrete path (the document root).
+*
+* @param obj - The object to query
 * @param path - JSONPath string (e.g., `"$.packages[*].version"`)
-* @param value - The value to set at each matching location
-* @returns The number of locations updated (0 if no matches or empty path)
+* @returns Array of concrete paths, each an array of string keys / numeric indices
 *
 * @example
 * ```typescript
-* import { jsonPathSet } from "../utils/jsonpath.js";
+* import { jsonPathResolve } from "../utils/jsonpath.js";
 *
-* const obj = { version: "1.0.0" };
-* const count = jsonPathSet(obj, "$.version", "2.0.0");
-* // count === 1, obj.version === "2.0.0"
+* const obj = { packages: [{ version: "1.0.0" }, { version: "2.0.0" }] };
+* const paths = jsonPathResolve(obj, "$.packages[*].version");
+* // [["packages", 0, "version"], ["packages", 1, "version"]]
 * ```
 *
 * @internal
 */
-function jsonPathSet(obj, path, value) {
-	const segments = parseJsonPath(path);
-	if (segments.length === 0) return 0;
-	const lastSegment = segments[segments.length - 1];
-	const parentSegments = segments.slice(0, -1);
-	let parents = [obj];
-	for (const segment of parentSegments) {
-		const next = [];
-		for (const node of parents) {
-			if (node === null || node === void 0 || typeof node !== "object") continue;
-			switch (segment.type) {
-				case "property": {
-					const child = node[segment.key];
-					if (child !== void 0) next.push(child);
-					break;
-				}
-				case "index":
-					if (Array.isArray(node) && segment.index < node.length) next.push(node[segment.index]);
-					break;
-				case "wildcard":
-					if (Array.isArray(node)) next.push(...node);
-					break;
-			}
-		}
-		parents = next;
-	}
-	let count = 0;
-	for (const parent of parents) {
-		if (parent === null || parent === void 0 || typeof parent !== "object") continue;
-		switch (lastSegment.type) {
-			case "property":
-				if (lastSegment.key in parent) {
-					parent[lastSegment.key] = value;
-					count++;
-				}
-				break;
-			case "index":
-				if (Array.isArray(parent) && lastSegment.index < parent.length) {
-					parent[lastSegment.index] = value;
-					count++;
-				}
-				break;
-			case "wildcard":
-				if (Array.isArray(parent)) for (let i = 0; i < parent.length; i++) {
-					parent[i] = value;
-					count++;
-				}
-				break;
-		}
-	}
-	return count;
+function jsonPathResolve(obj, path) {
+	return walkJsonPath(obj, path).map((entry) => entry.path);
 }
 //#endregion
 //#region ../silk-effects/dist/dev/pkg/changesets/utils/version-files.js
@@ -38530,31 +39823,39 @@ var VersionFiles = class VersionFiles {
 		return content.match(/^(\s+)"/m)?.[1] ?? "  ";
 	}
 	/**
-	* Update JSON file at specified JSONPath locations.
+	* Update a JSON (or JSONC) file at specified JSONPath locations,
+	* preserving the original formatting byte-for-byte.
 	*
 	* @remarks
-	* Reads the file, detects its indentation style and trailing newline
-	* preference, applies all JSONPath updates via {@link jsonPathSet},
-	* and writes the result back preserving the original formatting.
-	* Returns `undefined` if no JSONPath locations matched (no write occurs).
+	* The write is performed with `jsonc-effect`'s format-preserving
+	* `modify`/`applyEdits` rather than a `JSON.parse`/`JSON.stringify`
+	* round-trip (which always explodes inline arrays one-element-per-line and
+	* drops comments). Each JSONPath expression is resolved to concrete
+	* `(string | number)[]` paths against the parsed document, and each
+	* concrete path becomes a minimal text edit that touches only the target
+	* value's span — so inline arrays, comments,
+	* indentation, and the trailing-newline preference all survive; a one-line
+	* version bump produces a one-line diff.
+	*
+	* Insertion semantics: a concrete, wildcard-free JSONPath whose leaf
+	* property does not exist yet is inserted after the last sibling using the
+	* document's detected indent (the one case where indent detection still
+	* matters). Wildcard expressions only ever update existing matches. Returns
+	* `undefined` (no write) when nothing was updated or inserted.
 	*
 	* @param filePath - Absolute path to the JSON file
 	* @param jsonPaths - JSONPath expressions to update
 	* @param version - New version string
 	* @returns Update result, or `undefined` if no changes were made
+	*
+	* @see {@link jsonPathResolve} for concrete-path enumeration
+	* @see {@link VersionFiles.applyVersionEdit} for the per-path edit
 	*/
 	static updateFile(filePath, jsonPaths, version) {
-		const content = (0, node_fs.readFileSync)(filePath, "utf-8");
-		const indent = VersionFiles.detectIndent(content);
-		const trailingNewline = content.endsWith("\n");
-		const obj = JSON.parse(content);
-		const previousValues = jsonPaths.flatMap((jp) => jsonPathGet(obj, jp));
-		let totalUpdated = 0;
-		for (const jp of jsonPaths) totalUpdated += jsonPathSet(obj, jp, version);
-		if (totalUpdated === 0) return;
-		let output = JSON.stringify(obj, null, indent);
-		if (trailingNewline) output += "\n";
-		(0, node_fs.writeFileSync)(filePath, output, "utf-8");
+		const original = (0, node_fs.readFileSync)(filePath, "utf-8");
+		const { content, previousValues, totalChanged } = VersionFiles.computeUpdate(original, jsonPaths, version);
+		if (totalChanged === 0) return;
+		(0, node_fs.writeFileSync)(filePath, content, "utf-8");
 		return {
 			filePath,
 			jsonPaths,
@@ -38563,6 +39864,83 @@ var VersionFiles = class VersionFiles {
 		};
 	}
 	/**
+	* Compute the full update for a document without touching the filesystem:
+	* the edited content, the previous values at every matched path, and how
+	* many locations actually changed.
+	*
+	* @remarks
+	* This is the single decision path shared by {@link VersionFiles.updateFile}
+	* and the dry-run branches of the two process methods, so a preview reports
+	* exactly the files a real run would write — including pending inserts of a
+	* not-yet-existing wildcard-free leaf, and excluding same-value no-ops.
+	*
+	* @param original - Document text as read from disk
+	* @param jsonPaths - JSONPath expressions to update
+	* @param version - New version string
+	* @returns The updated content, previous values, and changed-location count
+	*/
+	static computeUpdate(original, jsonPaths, version) {
+		let content = original;
+		const obj = effect.Effect.runSync(parse$2(content));
+		const previousValues = jsonPaths.flatMap((jp) => jsonPathGet(obj, jp));
+		const indent = VersionFiles.detectIndent(content);
+		const eol = content.includes("\r\n") ? "\r\n" : "\n";
+		let totalChanged = 0;
+		for (const jp of jsonPaths) {
+			const segments = parseJsonPath(jp);
+			if (segments.length === 0) continue;
+			const hasWildcard = segments.some((segment) => segment.type === "wildcard");
+			let concretePaths;
+			if (hasWildcard) concretePaths = jsonPathResolve(obj, jp);
+			else {
+				const direct = segments.map((segment) => segment.type === "property" ? segment.key : segment.index);
+				concretePaths = jsonPathResolve(obj, jp).length > 0 || typeof direct[direct.length - 1] === "string" ? [direct] : [];
+			}
+			for (const concretePath of concretePaths) {
+				const updated = VersionFiles.applyVersionEdit(content, concretePath, version, indent, eol);
+				if (updated !== void 0) {
+					content = updated;
+					totalChanged += 1;
+				}
+			}
+		}
+		return {
+			content,
+			previousValues,
+			totalChanged
+		};
+	}
+	/**
+	* Compute the format-preserving edit for a single concrete path, returning
+	* the updated document, or `undefined` when nothing changed.
+	*
+	* @remarks
+	* Delegates to `jsonc-effect`'s {@link modify} + {@link applyEdits}
+	* (requires `jsonc-effect >= 0.3.1`, whose edit spans touch only the target
+	* value), so every other byte of the document is preserved. When the leaf
+	* of a wildcard-free path does not exist, `modify` inserts the property
+	* after the last sibling using the supplied formatting options — the only
+	* case where the detected indent matters. A path whose parent is missing or
+	* not an object cannot be navigated; the resulting modification error is
+	* caught and reported as "no change" so the file is left alone.
+	*
+	* @param content - Current document text
+	* @param concretePath - A wildcard-free `(string | number)[]` path
+	* @param version - New version string
+	* @param indentUnit - One indentation level, for inserted text
+	* @param eol - End-of-line sequence, for inserted text
+	* @returns The updated document, or `undefined` if the path was unchanged
+	*/
+	static applyVersionEdit(content, concretePath, version, indentUnit, eol) {
+		const insertSpaces = !indentUnit.includes("	");
+		const program = modify(content, [...concretePath], version, { formattingOptions: {
+			insertSpaces,
+			tabSize: insertSpaces ? indentUnit.length : 1,
+			eol
+		} }).pipe(effect.Effect.flatMap((edits) => applyEdits$1(content, edits)), effect.Effect.map((updated) => updated === content ? void 0 : updated), effect.Effect.catchTag("JsoncModificationError", () => effect.Effect.succeed(void 0)));
+		return effect.Effect.runSync(program);
+	}
+	/**
 	* Orchestrate the full version file update flow.
 	*
 	* @remarks
@@ -38588,9 +39966,8 @@ var VersionFiles = class VersionFiles {
 			try {
 				if (dryRun) {
 					const content = (0, node_fs.readFileSync)(filePath, "utf-8");
-					const obj = JSON.parse(content);
-					const previousValues = jsonPaths.flatMap((jp) => jsonPathGet(obj, jp));
-					if (previousValues.length > 0) updates.push({
+					const { previousValues, totalChanged } = VersionFiles.computeUpdate(content, jsonPaths, version);
+					if (totalChanged > 0) updates.push({
 						filePath,
 						jsonPaths,
 						version,
@@ -38634,9 +40011,8 @@ var VersionFiles = class VersionFiles {
 			for (const filePath of vf.matchedFiles) try {
 				if (dryRun) {
 					const content = (0, node_fs.readFileSync)(filePath, "utf-8");
-					const obj = JSON.parse(content);
-					const previousValues = jsonPaths.flatMap((jp) => jsonPathGet(obj, jp));
-					if (previousValues.length > 0) updates.push({
+					const { previousValues, totalChanged } = VersionFiles.computeUpdate(content, jsonPaths, scope.version);
+					if (totalChanged > 0) updates.push({
 						filePath,
 						jsonPaths,
 						version: scope.version,