@savvy-web/silk 2.1.0 → 2.1.2

package/changesets-changelog.cjs

@@ -358,7 +358,7 @@ const ChangesetConfigLive = effect.Layer.effect(ChangesetConfig, effect.Effect.g
 	};
 }));
 //#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}.
 *
@@ -385,7 +385,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}.
 *
@@ -411,7 +411,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}.
 *
@@ -436,7 +436,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}.
 *
@@ -487,7 +487,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}.
 *
@@ -538,7 +538,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}.
 *
@@ -588,7 +588,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.
 *
@@ -638,7 +638,7 @@ var WorkspaceRootNotFoundError = class extends WorkspaceRootNotFoundErrorBase {
 */
 var WorkspaceDiscovery = class extends effect.Context.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.
 *
@@ -685,7 +685,7 @@ var WorkspaceDiscovery = class extends effect.Context.Tag("@spencerbeggs/workspa
 */
 var WorkspaceRoot = class extends effect.Context.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.
 *
@@ -743,7 +743,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.
 *
@@ -796,7 +796,7 @@ var YamlErrorDetail = class extends effect.Schema.Class("YamlErrorDetail")({
 	column: effect.Schema.Int.pipe(effect.Schema.nonNegative())
 }) {};
 //#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.
 *
@@ -832,7 +832,7 @@ var CstNode = class CstNode extends effect.Schema.Class("CstNode")({
 	children: effect.Schema.optional(effect.Schema.Array(effect.Schema.suspend(() => 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.
 *
@@ -860,7 +860,7 @@ effect.Schema.Class("YamlEdit")({
 	content: effect.Schema.String
 });
 //#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.
@@ -1071,7 +1071,7 @@ var YamlSeq = class extends effect.Schema.TaggedClass()("YamlSeq", {
 	length: effect.Schema.Int.pipe(effect.Schema.nonNegative())
 }) {};
 //#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.
 *
@@ -1149,7 +1149,7 @@ var YamlDocument = class extends effect.Schema.Class("YamlDocument")({
 	hasDocumentStartTab: effect.Schema.optionalWith(effect.Schema.Boolean, { default: () => false })
 }) {};
 //#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.
 *
@@ -1184,7 +1184,7 @@ var YamlToken = class extends effect.Schema.Class("YamlToken")({
 	column: effect.Schema.Int.pipe(effect.Schema.nonNegative())
 }) {};
 //#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.
 *
@@ -1214,7 +1214,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;
@@ -2165,7 +2165,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({
@@ -2189,7 +2189,7 @@ function lexAll(text) {
 	return effect.Stream.runCollect(lex(text)).pipe(effect.Effect.map((chunk) => [...chunk]));
 }
 //#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.
 *
@@ -2834,7 +2834,7 @@ function parseCSTAll(text) {
 	return lexAll(text).pipe(effect.Effect.map((tokens) => parseDocuments(tokens, 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.
 *
@@ -2843,16 +2843,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|~)$/;
@@ -6296,7 +6309,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) {
@@ -6311,14 +6324,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(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) => {
@@ -6379,7 +6392,7 @@ function checkDefaultCatalogIsDefinedOnce(manifest) {
 	if (manifest.catalog != null && manifest.catalogs?.default != null) throw new PnpmError("INVALID_CATALOGS_CONFIGURATION", "The 'default' catalog was defined multiple times. Use the 'catalog' field or 'catalogs.default', but not both.");
 }
 //#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 = {};
@@ -6460,7 +6473,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",
@@ -6530,7 +6543,7 @@ function resolveManifest(catalogs, workspaceVersions, manifest) {
 	return out;
 }
 //#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.
@@ -6620,7 +6633,7 @@ var CatalogSet = class CatalogSet extends effect.Schema.Class("CatalogSet")({ en
 	}
 };
 //#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
@@ -6637,7 +6650,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`.
 *
@@ -8165,7 +8178,7 @@ minimatch.Minimatch = Minimatch;
 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.
 *
@@ -8427,7 +8440,1286 @@ effect.Schema.Class("WorkspaceInfo")({
 	patterns: effect.Schema.Array(effect.Schema.String)
 });
 //#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 = 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,
 	value: effect.Schema.String
@@ -8496,7 +9788,7 @@ var WorkspaceStateSnapshot = class extends effect.Schema.Class("WorkspaceStateSn
 	}
 };
 //#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
@@ -8523,7 +9815,7 @@ var WorkspaceStateSnapshot = class extends effect.Schema.Class("WorkspaceStateSn
 */
 var PointInTimeWorkspace = class extends effect.Context.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$1 = (pattern) => pattern.replace(/\/\*\*$/, "/*");
 const toRegex = (glob) => new RegExp(`^${glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")}$`);
 /**
@@ -8566,7 +9858,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."
@@ -8658,7 +9950,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.
 *
@@ -8713,7 +10005,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.
 *
@@ -8799,7 +10091,7 @@ const PointInTimeWorkspaceLive = effect.Layer.effect(PointInTimeWorkspace, effec
 	});
 }));
 //#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.
 *
@@ -8842,7 +10134,7 @@ var PublishTarget = class extends effect.Schema.Class("PublishTarget")({
 	provenance: effect.Schema.optionalWith(effect.Schema.Boolean, { default: () => false })
 }) {};
 //#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.).
@@ -8904,7 +10196,7 @@ var PublishTarget = class extends effect.Schema.Class("PublishTarget")({
 */
 var PublishabilityDetector = class extends effect.Context.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.
 *
@@ -8976,7 +10268,7 @@ const PublishabilityDetectorLive = effect.Layer.succeed(PublishabilityDetector,
 	return targets;
 }).pipe(effect.Effect.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.
 *
@@ -9263,7 +10555,7 @@ const WorkspaceDiscoveryLive = effect.Layer.effect(WorkspaceDiscovery, effect.Ef
 	};
 }));
 //#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.
 *
@@ -34052,7 +35344,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__ */ (0, module$1.createRequire)(require("url").pathToFileURL(__filename).href);
 function cleanPath(path$11) {
 	let normalized = (0, path.normalize)(path$11);
@@ -34560,7 +35852,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}]`;
@@ -34729,7 +36021,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$1 = /* @__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);
@@ -34777,7 +36069,7 @@ var require_utils$1 = /* @__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$1();
 	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();
@@ -35064,7 +36356,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = scan;
 }));
 //#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$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const constants = require_constants();
 	const utils = require_utils$1();
@@ -35219,7 +36511,10 @@ var require_parse$1 = /* @__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) {
@@ -35233,7 +36528,7 @@ var require_parse$1 = /* @__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;
@@ -35253,14 +36548,28 @@ var require_parse$1 = /* @__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 };
 	};
 	/**
@@ -36121,7 +37430,7 @@ var require_parse$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = parse;
 }));
 //#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$1();
@@ -36142,6 +37451,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.
@@ -36260,8 +37581,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`.
@@ -38194,23 +39515,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;
 			}
 		}
@@ -38219,81 +39563,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).
+*
+* 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 modify in-place
+* @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
@@ -38484,31 +39784,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,
@@ -38517,6 +39825,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
@@ -38542,9 +39927,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,
@@ -38588,9 +39972,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,