@savvy-web/changelog 0.1.0 → 0.1.1

package/index.js

@@ -3592,7 +3592,7 @@ const Order$1 = number;
 * @since 2.0.0
 * @category constructors
 */
-const parse$3 = (s) => {
+const parse$4 = (s) => {
 	if (s === "NaN") return some$1(NaN);
 	if (s === "Infinity") return some$1(Infinity);
 	if (s === "-Infinity") return some$1(-Infinity);
@@ -12585,7 +12585,7 @@ const set = /*#__PURE__*/ dual(2, (self, value) => self.modify(() => [void 0, va
 /** @internal */
 const getAndSet$1 = /*#__PURE__*/ dual(2, (self, value) => self.modify((a) => [a, value]));
 /** @internal */
-const modify = /*#__PURE__*/ dual(2, (self, f) => self.modify(f));
+const modify$1 = /*#__PURE__*/ dual(2, (self, f) => self.modify(f));
 /** @internal */
 const update$1 = /*#__PURE__*/ dual(2, (self, f) => self.modify((a) => [void 0, f(a)]));
 
@@ -17634,7 +17634,7 @@ var MemoMapImpl = class {
 				const resource = uninterruptibleMask$2((restore) => pipe$1(scopeMake(), flatMap$4((innerScope) => pipe$1(restore(flatMap$4(makeBuilder(layer, innerScope, true), (f) => diffFiberRefs(f(this)))), exit$3, flatMap$4((exit) => {
 					switch (exit._tag) {
 						case OP_FAILURE: return pipe$1(deferredFailCause(deferred, exit.effect_instruction_i0), zipRight$2(scopeClose(innerScope, exit)), zipRight$2(failCause$4(exit.effect_instruction_i0)));
-						case OP_SUCCESS: return pipe$1(set(finalizerRef, (exit) => pipe$1(scopeClose(innerScope, exit), whenEffect(modify(observers, (n) => [n === 1, n - 1])), asVoid)), zipRight$2(update$1(observers, (n) => n + 1)), zipRight$2(scopeAddFinalizerExit(scope, (exit) => pipe$1(sync$3(() => map.delete(layer)), zipRight$2(get(finalizerRef)), flatMap$4((finalizer) => finalizer(exit))))), zipRight$2(deferredSucceed(deferred, exit.effect_instruction_i0)), as$1(exit.effect_instruction_i0[1]));
+						case OP_SUCCESS: return pipe$1(set(finalizerRef, (exit) => pipe$1(scopeClose(innerScope, exit), whenEffect(modify$1(observers, (n) => [n === 1, n - 1])), asVoid)), zipRight$2(update$1(observers, (n) => n + 1)), zipRight$2(scopeAddFinalizerExit(scope, (exit) => pipe$1(sync$3(() => map.delete(layer)), zipRight$2(get(finalizerRef)), flatMap$4((finalizer) => finalizer(exit))))), zipRight$2(deferredSucceed(deferred, exit.effect_instruction_i0)), as$1(exit.effect_instruction_i0[1]));
 					}
 				})))));
 				const memoized = [pipe$1(deferredAwait(deferred), onExit$1(exitMatchEffect({
@@ -24792,7 +24792,7 @@ const nonNegative = (annotations) => greaterThanOrEqualTo(0, {
 function parseNumber(self) {
 	return transformOrFail(self, Number$, {
 		strict: false,
-		decode: (i, _, ast) => fromOption(parse$3(i), () => new Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a number`)),
+		decode: (i, _, ast) => fromOption(parse$4(i), () => new Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a number`)),
 		encode: (a) => succeed(String(a))
 	});
 }
@@ -26275,7 +26275,7 @@ const ChangesetConfigLive = effect$1(ChangesetConfig, gen(function* () {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/errors/CatalogAssemblyError.js
+//#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/errors/CatalogAssemblyError.js
 /**
 * Base constant for {@link CatalogAssemblyError}.
 *
@@ -26303,7 +26303,7 @@ var CatalogAssemblyError = class extends CatalogAssemblyErrorBase {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/errors/CatalogResolutionError.js
+//#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/errors/CatalogResolutionError.js
 /**
 * Base constant for {@link CatalogResolutionError}.
 *
@@ -26330,7 +26330,7 @@ var CatalogResolutionError = class extends CatalogResolutionErrorBase {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/errors/GitReadError.js
+//#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/errors/GitReadError.js
 /**
 * Base constant for {@link GitReadError}.
 *
@@ -26356,7 +26356,7 @@ var GitReadError = class extends GitReadErrorBase {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/errors/PackageNotFoundError.js
+//#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/errors/PackageNotFoundError.js
 /**
 * Base constant for {@link PackageNotFoundError}.
 *
@@ -26408,7 +26408,7 @@ var PackageNotFoundError = class extends PackageNotFoundErrorBase {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/errors/WorkspaceDiscoveryError.js
+//#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/errors/WorkspaceDiscoveryError.js
 /**
 * Base constant for {@link WorkspaceDiscoveryError}.
 *
@@ -26460,7 +26460,7 @@ var WorkspaceDiscoveryError = class extends WorkspaceDiscoveryErrorBase {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/errors/WorkspaceRootNotFoundError.js
+//#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/errors/WorkspaceRootNotFoundError.js
 /**
 * Base constant for {@link WorkspaceRootNotFoundError}.
 *
@@ -26511,7 +26511,7 @@ var WorkspaceRootNotFoundError = class extends WorkspaceRootNotFoundErrorBase {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/services/WorkspaceDiscovery.js
+//#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/services/WorkspaceDiscovery.js
 /**
 * Service for discovering workspace packages in a monorepo.
 *
@@ -26562,7 +26562,7 @@ var WorkspaceRootNotFoundError = class extends WorkspaceRootNotFoundErrorBase {
 var WorkspaceDiscovery = class extends Tag("@spencerbeggs/workspaces-effect/WorkspaceDiscovery")() {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/services/WorkspaceRoot.js
+//#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/services/WorkspaceRoot.js
 /**
 * Service for finding the workspace root directory.
 *
@@ -26610,7 +26610,7 @@ var WorkspaceDiscovery = class extends Tag("@spencerbeggs/workspaces-effect/Work
 var WorkspaceRoot = class extends Tag("@spencerbeggs/workspaces-effect/WorkspaceRoot")() {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml-effect@0.7.0_effect@3.21.4/node_modules/yaml-effect/errors/YamlComposerError.js
+//#region ../../node_modules/.pnpm/yaml-effect@0.7.2_effect@3.21.4/node_modules/yaml-effect/errors/YamlComposerError.js
 /**
 * YAML composer error type.
 *
@@ -26669,7 +26669,7 @@ var YamlComposerError = class extends YamlComposerErrorBase {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml-effect@0.7.0_effect@3.21.4/node_modules/yaml-effect/errors/YamlErrorDetail.js
+//#region ../../node_modules/.pnpm/yaml-effect@0.7.2_effect@3.21.4/node_modules/yaml-effect/errors/YamlErrorDetail.js
 /**
 * YAML error detail schema and error code types.
 *
@@ -26723,7 +26723,7 @@ var YamlErrorDetail = class extends Class("YamlErrorDetail")({
 }) {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml-effect@0.7.0_effect@3.21.4/node_modules/yaml-effect/schemas/CstNode.js
+//#region ../../node_modules/.pnpm/yaml-effect@0.7.2_effect@3.21.4/node_modules/yaml-effect/schemas/CstNode.js
 /**
 * YAML CST node schema and node type literal union.
 *
@@ -26760,7 +26760,7 @@ var CstNode = class CstNode extends Class("CstNode")({
 }) {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml-effect@0.7.0_effect@3.21.4/node_modules/yaml-effect/schemas/YamlShared.js
+//#region ../../node_modules/.pnpm/yaml-effect@0.7.2_effect@3.21.4/node_modules/yaml-effect/schemas/YamlShared.js
 /**
 * Shared YAML structural types used across the parse/stringify/format pipeline.
 *
@@ -26835,7 +26835,7 @@ var YamlEdit = class extends Class("YamlEdit")({
 }) {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml-effect@0.7.0_effect@3.21.4/node_modules/yaml-effect/schemas/YamlAstNodes.js
+//#region ../../node_modules/.pnpm/yaml-effect@0.7.2_effect@3.21.4/node_modules/yaml-effect/schemas/YamlAstNodes.js
 /**
 * Internal module defining all mutually-referential YAML AST node schemas in
 * one place to avoid circular import cycles between individual schema files.
@@ -27047,7 +27047,7 @@ var YamlSeq = class extends TaggedClass()("YamlSeq", {
 }) {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml-effect@0.7.0_effect@3.21.4/node_modules/yaml-effect/schemas/YamlDocument.js
+//#region ../../node_modules/.pnpm/yaml-effect@0.7.2_effect@3.21.4/node_modules/yaml-effect/schemas/YamlDocument.js
 /**
 * YAML document and directive schemas.
 *
@@ -27126,7 +27126,7 @@ var YamlDocument = class extends Class("YamlDocument")({
 }) {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml-effect@0.7.0_effect@3.21.4/node_modules/yaml-effect/schemas/YamlToken.js
+//#region ../../node_modules/.pnpm/yaml-effect@0.7.2_effect@3.21.4/node_modules/yaml-effect/schemas/YamlToken.js
 /**
 * YAML token schema and token kind literal union.
 *
@@ -27162,7 +27162,7 @@ var YamlToken = class extends Class("YamlToken")({
 }) {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml-effect@0.7.0_effect@3.21.4/node_modules/yaml-effect/utils/lexer.js
+//#region ../../node_modules/.pnpm/yaml-effect@0.7.2_effect@3.21.4/node_modules/yaml-effect/utils/lexer.js
 /**
 * YAML 1.2 lexer — tokenizes raw YAML text into a stream of {@link YamlToken} values.
 *
@@ -27192,7 +27192,7 @@ var YamlToken = class extends Class("YamlToken")({
 *
 * @public
 */
-function createScanner$1(text) {
+function createScanner$2(text) {
 	let pos = 0;
 	let line = 0;
 	let col = 0;
@@ -28143,7 +28143,7 @@ function createScanner$1(text) {
 * @public
 */
 function lex(text) {
-	return unfold(createScanner$1(text), (scanner) => {
+	return unfold(createScanner$2(text), (scanner) => {
 		const kind = scanner.scan();
 		if (kind === null) return none$4();
 		const token = new YamlToken({
@@ -28168,7 +28168,7 @@ function lexAll(text) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml-effect@0.7.0_effect@3.21.4/node_modules/yaml-effect/utils/parser.js
+//#region ../../node_modules/.pnpm/yaml-effect@0.7.2_effect@3.21.4/node_modules/yaml-effect/utils/parser.js
 /**
 * YAML 1.2 CST parser — transforms a token stream into a Concrete Syntax Tree.
 *
@@ -28814,7 +28814,7 @@ function parseCSTAll(text) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/yaml-effect@0.7.0_effect@3.21.4/node_modules/yaml-effect/utils/composer.js
+//#region ../../node_modules/.pnpm/yaml-effect@0.7.2_effect@3.21.4/node_modules/yaml-effect/utils/composer.js
 /**
 * YAML 1.2 Composer — transforms CST nodes into AST nodes with typed values.
 *
@@ -28823,16 +28823,29 @@ function parseCSTAll(text) {
 *
 * @packageDocumentation
 */
+let lineStartsText;
+let lineStartsCache = [];
+function getLineStarts(text) {
+	if (lineStartsText === text) return lineStartsCache;
+	const starts = [0];
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n") starts.push(i + 1);
+	lineStartsText = text;
+	lineStartsCache = starts;
+	return starts;
+}
 function lineCol(text, offset) {
-	let line = 0;
-	let column = 0;
-	for (let i = 0; i < offset && i < text.length; i++) if (text[i] === "\n") {
-		line++;
-		column = 0;
-	} else column++;
+	const starts = getLineStarts(text);
+	const pos = Math.min(Math.max(offset, 0), text.length);
+	let lo = 0;
+	let hi = starts.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >> 1;
+		if (starts[mid] <= pos) lo = mid;
+		else hi = mid - 1;
+	}
 	return {
-		line,
-		column
+		line: lo,
+		column: pos - starts[lo]
 	};
 }
 const NULL_RE = /^(?:null|Null|NULL|~)$/;
@@ -32276,7 +32289,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(flatMap$2((doc) => {
 		if (uniqueKeys) {
@@ -32292,14 +32305,14 @@ function parse$2(text, options) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/layers/catalog/workspace-manifest.js
+//#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/layers/catalog/workspace-manifest.js
 /**
 * Parse a pnpm-workspace.yaml text into its catalog/config-dependency/packages
 * slice. Pure with respect to the filesystem.
 *
 * @public
 */
-const workspaceManifestFromYaml = (content) => parse$2(content).pipe(mapError$1((e) => new CatalogAssemblyError({
+const workspaceManifestFromYaml = (content) => parse$3(content).pipe(mapError$1((e) => new CatalogAssemblyError({
 	source: "manifest",
 	reason: `invalid yaml: ${String(e)}`
 })), map$5((parsed) => {
@@ -32368,7 +32381,7 @@ function checkDefaultCatalogIsDefinedOnce(manifest) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/layers/catalog/assemble.js
+//#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/layers/catalog/assemble.js
 /** Merge catalog sources; later sources win per dependency within a catalog. */
 function mergeCatalogs(...sources) {
 	const result = {};
@@ -32453,7 +32466,7 @@ function resolveFromCatalog(catalogs, wantedDependency) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/layers/catalog/resolve.js
+//#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/layers/catalog/resolve.js
 const DEP_FIELDS = [
 	"dependencies",
 	"devDependencies",
@@ -32524,7 +32537,7 @@ function resolveManifest(catalogs, workspaceVersions, manifest) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/schemas/CatalogSet.js
+//#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/CatalogSet.js
 /**
 * An immutable, fully-normalized catalog collection with the one
 * resolution semantic shared by live and point-in-time resolution.
@@ -32615,7 +32628,7 @@ var CatalogSet = class CatalogSet extends Class("CatalogSet")({ entries: Record(
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/layers/point-in-time/worktree-catalogs.js
+//#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/layers/point-in-time/worktree-catalogs.js
 /**
 * The ONE code path that reads the working tree's catalog sources
 * (`pnpm-workspace.yaml` + `pnpm-lock.yaml`). Consumed by
@@ -32632,7 +32645,7 @@ var CatalogSet = class CatalogSet extends Class("CatalogSet")({ entries: Record(
 *
 * @internal
 */
-const lockfileCatalogsFromText = (text) => parse$2(text).pipe(map$5((parsed) => CatalogSet.fromLockfileCatalogs(parsed?.catalogs)), orElseSucceed(() => CatalogSet.empty()));
+const lockfileCatalogsFromText = (text) => parse$3(text).pipe(map$5((parsed) => CatalogSet.fromLockfileCatalogs(parsed?.catalogs)), orElseSucceed(() => CatalogSet.empty()));
 /**
 * Read the working tree's catalog state at `root`.
 *
@@ -34171,7 +34184,7 @@ minimatch.escape = escape;
 minimatch.unescape = unescape;
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/schemas/core.js
+//#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/core.js
 /**
 * Schema for supported package manager identifiers.
 *
@@ -34499,7 +34512,1302 @@ var WorkspaceInfo = class extends Class("WorkspaceInfo")({
 }) {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/schemas/WorkspaceStateSnapshot.js
+//#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 = 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 Class("JsoncParseErrorDetail")({
+	code: JsoncParseErrorCode,
+	message: String$,
+	offset: Number$,
+	length: Number$,
+	startLine: Number$,
+	startCharacter: 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 = 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("; ")}`;
+	}
+};
+/**
+* Base class for {@link JsoncNodeNotFoundError}; not intended to be
+* constructed or caught directly — use `JsoncNodeNotFoundError` 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 JsoncNodeNotFoundErrorBase = 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 = 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) => sync$2(() => parseInternal(text, options ?? {}, false)).pipe(flatMap$2(({ value, errors }) => {
+	if (errors.length > 0) return fail$2(new JsoncParseError({
+		errors,
+		text,
+		...options !== void 0 ? { options } : {}
+	}));
+	return succeed$3(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 = dual(2, (text, edits) => sync$2(() => {
+	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 = dual((args) => typeof args[0] === "string" && Array.isArray(args[1]), (text, path, value, options) => 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 = optionalWith(Record({
 	key: String$,
 	value: String$
@@ -34569,7 +35877,7 @@ var WorkspaceStateSnapshot = class extends Class("WorkspaceStateSnapshot")({
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/services/PointInTimeWorkspace.js
+//#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/services/PointInTimeWorkspace.js
 /**
 * Service for reading a monorepo's workspace state at a specific moment: any
 * git ref (via `git show`/`git ls-tree`, without checking the ref out) or the
@@ -34597,7 +35905,7 @@ var WorkspaceStateSnapshot = class extends Class("WorkspaceStateSnapshot")({
 var PointInTimeWorkspace = class extends Tag("@spencerbeggs/workspaces-effect/PointInTimeWorkspace")() {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/layers/discovery/glob-core.js
+//#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/layers/discovery/glob-core.js
 const normalize$2 = (pattern) => pattern.replace(/\/\*\*$/, "/*");
 const toRegex = (glob) => new RegExp(`^${glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")}$`);
 /**
@@ -34641,7 +35949,7 @@ const compileWorkspaceGlobs = (patterns) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/layers/point-in-time/git.js
+//#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/layers/point-in-time/git.js
 /**
 * Stderr shapes that mean "the path is not present at this ref" rather than
 * "the git command failed."
@@ -34734,7 +36042,7 @@ const makeGitReader = (executor, options) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/layers/PointInTimeWorkspaceLive.js
+//#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/layers/PointInTimeWorkspaceLive.js
 /**
 * Live layer for the {@link PointInTimeWorkspace} service.
 *
@@ -34789,7 +36097,7 @@ const packageSnapshotFromJson = (text, relativePath) => {
 *
 * @internal
 */
-const lockfileCatalogsAtRef = (text) => isNone(text) ? succeed$3(CatalogSet.empty()) : parse$2(text.value).pipe(map$5((parsed) => CatalogSet.fromLockfileCatalogs(parsed?.catalogs)), orElseSucceed(() => CatalogSet.empty()));
+const lockfileCatalogsAtRef = (text) => isNone(text) ? succeed$3(CatalogSet.empty()) : parse$3(text.value).pipe(map$5((parsed) => CatalogSet.fromLockfileCatalogs(parsed?.catalogs)), orElseSucceed(() => CatalogSet.empty()));
 /**
 * Live layer for the {@link PointInTimeWorkspace} service.
 *
@@ -34876,7 +36184,7 @@ const PointInTimeWorkspaceLive = effect$1(PointInTimeWorkspace, gen(function* ()
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/schemas/publish.js
+//#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/publish.js
 /**
 * Schema for package publish targets.
 *
@@ -34920,7 +36228,7 @@ var PublishTarget = class extends Class("PublishTarget")({
 }) {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/services/PublishabilityDetector.js
+//#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/services/PublishabilityDetector.js
 /**
 * Service for detecting whether a workspace package is publishable and
 * identifying its publish targets (npm, GitHub Packages, etc.).
@@ -34983,7 +36291,7 @@ var PublishTarget = class extends Class("PublishTarget")({
 var PublishabilityDetector = class extends Tag("@spencerbeggs/workspaces-effect/PublishabilityDetector")() {};
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/layers/PublishabilityDetectorLive.js
+//#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/layers/PublishabilityDetectorLive.js
 /**
 * Default live implementation of the {@link PublishabilityDetector} service.
 *
@@ -35056,7 +36364,7 @@ const PublishabilityDetectorLive = succeed$2(PublishabilityDetector, { detect: (
 }).pipe(withSpan("PublishabilityDetector.detect", { attributes: { "workspace.package": pkg.name } })) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/layers/WorkspaceDiscoveryLive.js
+//#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/layers/WorkspaceDiscoveryLive.js
 /**
 * Live implementation of the {@link WorkspaceDiscovery} service.
 *
@@ -35344,7 +36652,7 @@ const WorkspaceDiscoveryLive = effect$1(WorkspaceDiscovery, gen(function* () {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/workspaces-effect@2.0.1_@effect+platform@0.96.2_effect@3.21.4__effect@3.21.4/node_modules/workspaces-effect/layers/WorkspaceRootLive.js
+//#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/layers/WorkspaceRootLive.js
 /**
 * Live implementation of the {@link WorkspaceRoot} service.
 *
@@ -60367,7 +61675,7 @@ var ChangelogTransformer = class ChangelogTransformer {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.4/node_modules/fdir/dist/index.mjs
+//#region ../../node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.5/node_modules/fdir/dist/index.mjs
 var __require = /* @__PURE__ */ createRequire$1(import.meta.url);
 function cleanPath(path) {
 	let normalized = normalize(path);
@@ -60876,7 +62184,7 @@ var Builder = class {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/constants.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/constants.js
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const WIN_SLASH = "\\\\/";
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
@@ -61050,7 +62358,7 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/utils.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/utils.js
 var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
 	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
@@ -61099,7 +62407,7 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/scan.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/scan.js
 var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const utils = require_utils();
 	const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants();
@@ -61387,7 +62695,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/parse.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/parse.js
 var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const constants = require_constants();
 	const utils = require_utils();
@@ -61542,7 +62850,10 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			}
 		}
 	};
-	const getStarExtglobSequenceOutput = (pattern) => {
+	const buildCharClassStar = (chars) => {
+		return `${chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`}*`;
+	};
+	const getStarExtglobSequenceChars = (pattern) => {
 		let index = 0;
 		const chars = [];
 		while (index < pattern.length) {
@@ -61556,7 +62867,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			index += match.end + 1;
 		}
 		if (chars.length < 1) return;
-		return `${chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`}*`;
+		return chars;
 	};
 	const repeatedExtglobRecursion = (pattern) => {
 		let depth = 0;
@@ -61576,14 +62887,28 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		if (branches.length > 1) {
 			if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) return { risky: true };
 		}
+		const safeChars = [];
+		let sawStarSequence = false;
+		let combinable = true;
 		for (const branch of branches) {
-			const safeOutput = getStarExtglobSequenceOutput(branch);
-			if (safeOutput) return {
-				risky: true,
-				safeOutput
-			};
+			const chars = getStarExtglobSequenceChars(branch);
+			if (chars) {
+				sawStarSequence = true;
+				safeChars.push(...chars);
+				continue;
+			}
+			const literal = normalizeSimpleBranch(branch);
+			if (literal && literal.length === 1) {
+				safeChars.push(literal);
+				continue;
+			}
+			combinable = false;
 			if (repeatedExtglobRecursion(branch) > max) return { risky: true };
 		}
+		if (sawStarSequence) return combinable ? {
+			risky: true,
+			safeOutput: buildCharClassStar([...new Set(safeChars)])
+		} : { risky: true };
 		return { risky: false };
 	};
 	/**
@@ -62445,7 +63770,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/picomatch.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/picomatch.js
 var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const scan = require_scan();
 	const parse = require_parse();
@@ -62466,6 +63791,18 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* const isMatch = picomatch('*.!(*a)');
 	* console.log(isMatch('a.a')); //=> false
 	* console.log(isMatch('a.b')); //=> true
+	*
+	* // For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection.
+	* const picomatch = require('picomatch/posix');
+	* // the same API, defaulting to posix paths
+	* const isMatch = picomatch('a/*');
+	* console.log(isMatch('a\\b')); //=> false
+	* console.log(isMatch('a/b')); //=> true
+	*
+	* // you can still configure the matcher function to accept windows paths
+	* const isMatch = picomatch('a/*', { options: windows });
+	* console.log(isMatch('a\\b')); //=> true
+	* console.log(isMatch('a/b')); //=> true
 	* ```
 	* @name picomatch
 	* @param {String|Array} `globs` One or more glob patterns.
@@ -62584,8 +63921,8 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @return {Boolean}
 	* @api public
 	*/
-	picomatch.matchBase = (input, glob, options) => {
-		return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(utils.basename(input));
+	picomatch.matchBase = (input, glob, options, posix = options && options.windows) => {
+		return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(utils.basename(input, { windows: posix }));
 	};
 	/**
 	* Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -62746,7 +64083,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/index.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/index.js
 var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const pico = require_picomatch$1();
 	const utils = require_utils();
@@ -63748,15 +65085,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);
 		}
@@ -63891,6 +65229,32 @@ const DEP_TYPE_MAP = [
 */
 const resolveOrRaw = (snapshot, dep, spec) => 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.
 *
@@ -63946,10 +65310,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;
@@ -64292,7 +65657,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(provide$1(provideDetector));
 		const versionPrivate = yield* config.versionPrivate(resolvedCwd);
@@ -64301,9 +65667,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");
@@ -64314,7 +65686,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) {
@@ -64532,23 +65904,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;
 			}
 		}
@@ -64557,81 +65952,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
@@ -64823,31 +66174,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 = 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";
-		writeFileSync(filePath, output, "utf-8");
+		const original = readFileSync(filePath, "utf-8");
+		const { content, previousValues, totalChanged } = VersionFiles.computeUpdate(original, jsonPaths, version);
+		if (totalChanged === 0) return;
+		writeFileSync(filePath, content, "utf-8");
 		return {
 			filePath,
 			jsonPaths,
@@ -64856,6 +66215,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 = 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(flatMap$2((edits) => applyEdits$1(content, edits)), map$5((updated) => updated === content ? void 0 : updated), catchTag("JsoncModificationError", () => succeed$3(void 0)));
+		return runSync(program);
+	}
+	/**
 	* Orchestrate the full version file update flow.
 	*
 	* @remarks
@@ -64881,9 +66317,8 @@ var VersionFiles = class VersionFiles {
 			try {
 				if (dryRun) {
 					const content = 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,
@@ -64927,9 +66362,8 @@ var VersionFiles = class VersionFiles {
 			for (const filePath of vf.matchedFiles) try {
 				if (dryRun) {
 					const content = 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,
@@ -78909,14 +80343,6 @@ var changesets_exports = /* @__PURE__ */ __exportAll({
 
 //#endregion
 //#region src/index.ts
-/**
-* The silk changelog generator as a standalone installable package — the
-* canonical `changelog` id for `.changeset/config.json`. Thin re-export of
-* `@savvy-web/silk-effects`' changelog functions; silk-effects remains the
-* single source of truth.
-*
-* @packageDocumentation
-*/
 const changelogFunctions = changesets_exports.changelogFunctions;
 
 //#endregion