ryco-cli 0.1.25 → 0.1.26

package/dist/git-irmB8_k7.cjs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+
+const require_rolldown_runtime = require("./rolldown-runtime-LGfotAqq.cjs");
+const require_src = require("./src-BlzIcnVG.cjs");
+const require_sourceControl = require("./sourceControl-B0D1Op29.cjs");
+let effect_Effect = require("effect/Effect");
+effect_Effect = require_rolldown_runtime.__toESM(effect_Effect, 1);
+let effect_Random = require("effect/Random");
+effect_Random = require_rolldown_runtime.__toESM(effect_Random, 1);
+//#region ../../packages/shared/src/git.ts
+const WORKTREE_BRANCH_PREFIX = require_src.DEFAULT_WORKTREE_BRANCH_PREFIX;
+const LEGACY_WORKTREE_BRANCH_PREFIX = "ryco";
+/**
+* Sanitize an arbitrary string into a valid, lowercase git refName fragment.
+* Strips quotes, collapses separators, limits to 64 chars.
+*/
+function sanitizeBranchFragment(raw) {
+	const branchFragment = raw.trim().toLowerCase().replace(/['"`]/g, "").replace(/^[./\s_-]+|[./\s_-]+$/g, "").replace(/[^a-z0-9/_-]+/g, "-").replace(/\/+/g, "/").replace(/-+/g, "-").replace(/^[./_-]+|[./_-]+$/g, "").slice(0, 64).replace(/[./_-]+$/g, "");
+	return branchFragment.length > 0 ? branchFragment : "update";
+}
+/**
+* Sanitize a string into a `feature/…` refName name.
+* Preserves an existing `feature/` prefix or slash-separated namespace.
+*/
+function sanitizeFeatureBranchName(raw) {
+	const sanitized = sanitizeBranchFragment(raw);
+	if (sanitized.includes("/")) return sanitized.startsWith("feature/") ? sanitized : `feature/${sanitized}`;
+	return `feature/${sanitized}`;
+}
+const AUTO_FEATURE_BRANCH_FALLBACK = "feature/update";
+/**
+* Resolve a unique `feature/…` refName name that doesn't collide with
+* any existing refName. Appends a numeric suffix when needed.
+*/
+function resolveAutoFeatureBranchName(existingBranchNames, preferredBranch) {
+	const preferred = preferredBranch?.trim();
+	const resolvedBase = sanitizeFeatureBranchName(preferred && preferred.length > 0 ? preferred : AUTO_FEATURE_BRANCH_FALLBACK);
+	const existingNames = new Set(existingBranchNames.map((refName) => refName.toLowerCase()));
+	if (!existingNames.has(resolvedBase)) return resolvedBase;
+	let suffix = 2;
+	while (existingNames.has(`${resolvedBase}-${suffix}`)) suffix += 1;
+	return `${resolvedBase}-${suffix}`;
+}
+/**
+* Strip the remote prefix from a remote ref such as `origin/feature/demo`.
+*/
+function deriveLocalBranchNameFromRemoteRef(branchName) {
+	const firstSeparatorIndex = branchName.indexOf("/");
+	if (firstSeparatorIndex <= 0 || firstSeparatorIndex === branchName.length - 1) return branchName;
+	return branchName.slice(firstSeparatorIndex + 1);
+}
+/** Prefixes are validated by WorktreeBranchPrefix at the server settings boundary. */
+function prefixWorktreeBranch(fragment, prefix) {
+	return prefix.length > 0 ? `${prefix}/${fragment}` : fragment;
+}
+function buildTemporaryWorktreeBranchName(prefix = WORKTREE_BRANCH_PREFIX) {
+	return prefixWorktreeBranch(effect_Effect.runSync(effect_Random.nextIntBetween(0, 4294967295)).toString(16).padStart(8, "0"), prefix);
+}
+/** Returns the original namespace, retaining legacy drafts after a settings change. */
+function extractTemporaryWorktreeBranchPrefix(refName, prefix = WORKTREE_BRANCH_PREFIX) {
+	const ref = refName.trim();
+	for (const candidate of [prefix, LEGACY_WORKTREE_BRANCH_PREFIX]) {
+		const namespace = candidate.length > 0 ? `${candidate}/` : "";
+		if (ref.toLowerCase().startsWith(namespace.toLowerCase()) && /^[0-9a-f]{8}$/i.test(ref.slice(namespace.length))) return ref.slice(0, candidate.length);
+	}
+	return null;
+}
+function isTemporaryWorktreeBranch(refName, prefix = WORKTREE_BRANCH_PREFIX) {
+	return extractTemporaryWorktreeBranchPrefix(refName, prefix) !== null;
+}
+/** An empty namespace cannot establish ownership of arbitrary named branches. */
+function isManagedWorktreeBranch(refName, prefix = WORKTREE_BRANCH_PREFIX) {
+	const ref = refName.trim();
+	return [prefix, LEGACY_WORKTREE_BRANCH_PREFIX].some((candidate) => candidate.length > 0 && ref.startsWith(`${candidate}/`) && ref.length > candidate.length + 1) || isTemporaryWorktreeBranch(ref, prefix);
+}
+function buildGeneratedWorktreeBranchName(raw, prefix = WORKTREE_BRANCH_PREFIX) {
+	const normalized = raw.trim().replace(/^refs\/heads\//i, "").replace(/['"`]/g, "");
+	const existingPrefix = [prefix, LEGACY_WORKTREE_BRANCH_PREFIX].find((candidate) => candidate.length > 0 && normalized.toLowerCase().startsWith(`${candidate.toLowerCase()}/`));
+	return prefixWorktreeBranch(sanitizeBranchFragment(existingPrefix === void 0 ? normalized : normalized.slice(existingPrefix.length + 1)), prefix);
+}
+/**
+* Normalize a git remote URL into a stable comparison key.
+*/
+function normalizeGitRemoteUrl(value) {
+	const normalized = value.trim().replace(/\/+$/g, "").replace(/\.git$/i, "").toLowerCase();
+	if (/^(?:ssh|https?|git):\/\//i.test(normalized)) try {
+		const url = new URL(normalized);
+		const repositoryPath = url.pathname.split("/").filter((segment) => segment.length > 0).join("/");
+		if (url.hostname && repositoryPath.includes("/")) return `${url.hostname}/${repositoryPath}`;
+	} catch {
+		return normalized;
+	}
+	const scpStyleHostAndPath = /^git@([^:/\s]+)[:/]([^/\s]+(?:\/[^/\s]+)+)$/i.exec(normalized);
+	if (scpStyleHostAndPath?.[1] && scpStyleHostAndPath[2]) return `${scpStyleHostAndPath[1]}/${scpStyleHostAndPath[2]}`;
+	return normalized;
+}
+function deriveLocalBranchNameCandidatesFromRemoteRef(branchName, remoteName) {
+	const candidates = /* @__PURE__ */ new Set();
+	const firstSlashCandidate = deriveLocalBranchNameFromRemoteRef(branchName);
+	if (firstSlashCandidate.length > 0) candidates.add(firstSlashCandidate);
+	if (remoteName) {
+		const remotePrefix = `${remoteName}/`;
+		if (branchName.startsWith(remotePrefix) && branchName.length > remotePrefix.length) candidates.add(branchName.slice(remotePrefix.length));
+	}
+	return [...candidates];
+}
+/**
+* Hide `origin/*` remote refs when a matching local refName already exists.
+*/
+function dedupeRemoteBranchesWithLocalMatches(refs) {
+	const localBranchNames = new Set(refs.filter((refName) => !refName.isRemote).map((refName) => refName.name));
+	return refs.filter((refName) => {
+		if (!refName.isRemote) return true;
+		if (refName.remoteName !== "origin") return true;
+		return !deriveLocalBranchNameCandidatesFromRemoteRef(refName.name, refName.remoteName).some((candidate) => localBranchNames.has(candidate));
+	});
+}
+function detectSourceControlProviderFromGitRemoteUrl(remoteUrl) {
+	return require_sourceControl.detectSourceControlProviderFromRemoteUrl(remoteUrl);
+}
+const EMPTY_GIT_STATUS_REMOTE = {
+	hasUpstream: false,
+	aheadCount: 0,
+	behindCount: 0,
+	aheadOfDefaultCount: 0,
+	pr: null
+};
+function mergeGitStatusParts(local, remote) {
+	return {
+		...local,
+		...remote ?? EMPTY_GIT_STATUS_REMOTE
+	};
+}
+//#endregion
+Object.defineProperty(exports, "WORKTREE_BRANCH_PREFIX", {
+	enumerable: true,
+	get: function() {
+		return WORKTREE_BRANCH_PREFIX;
+	}
+});
+Object.defineProperty(exports, "buildGeneratedWorktreeBranchName", {
+	enumerable: true,
+	get: function() {
+		return buildGeneratedWorktreeBranchName;
+	}
+});
+Object.defineProperty(exports, "buildTemporaryWorktreeBranchName", {
+	enumerable: true,
+	get: function() {
+		return buildTemporaryWorktreeBranchName;
+	}
+});
+Object.defineProperty(exports, "dedupeRemoteBranchesWithLocalMatches", {
+	enumerable: true,
+	get: function() {
+		return dedupeRemoteBranchesWithLocalMatches;
+	}
+});
+Object.defineProperty(exports, "detectSourceControlProviderFromGitRemoteUrl", {
+	enumerable: true,
+	get: function() {
+		return detectSourceControlProviderFromGitRemoteUrl;
+	}
+});
+Object.defineProperty(exports, "extractTemporaryWorktreeBranchPrefix", {
+	enumerable: true,
+	get: function() {
+		return extractTemporaryWorktreeBranchPrefix;
+	}
+});
+Object.defineProperty(exports, "isManagedWorktreeBranch", {
+	enumerable: true,
+	get: function() {
+		return isManagedWorktreeBranch;
+	}
+});
+Object.defineProperty(exports, "isTemporaryWorktreeBranch", {
+	enumerable: true,
+	get: function() {
+		return isTemporaryWorktreeBranch;
+	}
+});
+Object.defineProperty(exports, "mergeGitStatusParts", {
+	enumerable: true,
+	get: function() {
+		return mergeGitStatusParts;
+	}
+});
+Object.defineProperty(exports, "normalizeGitRemoteUrl", {
+	enumerable: true,
+	get: function() {
+		return normalizeGitRemoteUrl;
+	}
+});
+Object.defineProperty(exports, "prefixWorktreeBranch", {
+	enumerable: true,
+	get: function() {
+		return prefixWorktreeBranch;
+	}
+});
+Object.defineProperty(exports, "resolveAutoFeatureBranchName", {
+	enumerable: true,
+	get: function() {
+		return resolveAutoFeatureBranchName;
+	}
+});
+Object.defineProperty(exports, "sanitizeBranchFragment", {
+	enumerable: true,
+	get: function() {
+		return sanitizeBranchFragment;
+	}
+});
+Object.defineProperty(exports, "sanitizeFeatureBranchName", {
+	enumerable: true,
+	get: function() {
+		return sanitizeFeatureBranchName;
+	}
+});

package/dist/{makeManagedServerProvider-CwYhl_P-.mjs → makeManagedServerProvider-BINne1KE.mjs}

@@ -1,44 +1,9 @@
 #!/usr/bin/env node
 
-import "./collectUint8StreamText-CE1Re5Ij.mjs";
-import { r as ignoreProviderBackgroundCause, wt as ProviderAdapterValidationError } from "./bin.mjs";
+import "./src-DtEOcXdl.mjs";
+import { r as ignoreProviderBackgroundCause } from "./bin.mjs";
 import { Clock, Deferred, Duration, Effect, Equal, Fiber, PubSub, Ref, Stream, SynchronizedRef } from "effect";
 import * as Semaphore$1 from "effect/Semaphore";
-//#region ../../packages/shared/src/attachmentPrompt.ts
-function formatAttachmentPathLine(entry) {
-	const attachment = entry.attachment;
-	const name = attachment.name ?? "attachment";
-	const mimeType = attachment.mimeType ?? "unknown";
-	const sizeText = attachment.sizeBytes === void 0 ? "size unknown" : `${attachment.sizeBytes}`;
-	if (attachment.id === void 0 || entry.resolvedPath === void 0) return `[Attached file] ${name} (${mimeType}, ${sizeText} bytes)`;
-	return `[Attached file] ${name} (${mimeType}, ${sizeText} bytes) saved at: ${entry.resolvedPath}`;
-}
-function formatAttachmentPathLines(entries) {
-	return entries.map(formatAttachmentPathLine);
-}
-function appendAttachmentPathLines(text, pathLines) {
-	if (pathLines.length === 0) return text;
-	const lines = pathLines.join("\n");
-	if (text === void 0 || text.trim().length === 0) return lines;
-	return `${text}\n\n${lines}`;
-}
-//#endregion
-//#region src/provider/runtimeSession.ts
-function requireRuntimeSessionId(provider, input) {
-	return input.runtimeSessionId !== void 0 ? Effect.succeed(input.runtimeSessionId) : Effect.fail(new ProviderAdapterValidationError({
-		provider,
-		operation: "startSession",
-		issue: "runtimeSessionId is required for new provider sessions."
-	}));
-}
-function stampRuntimeEvent(event, input) {
-	return {
-		...event,
-		providerInstanceId: input.providerInstanceId,
-		runtimeSessionId: input.runtimeSessionId
-	};
-}
-//#endregion
 //#region src/provider/makeManagedServerProvider.ts
 const DEFAULT_SNAPSHOT_FRESHNESS = Duration.minutes(5);
 const isProviderSnapshotFresh = (input) => input.lastRefreshAttemptAtMs !== null && input.nowMs - input.lastRefreshAttemptAtMs < input.freshnessMs;
@@ -151,4 +116,4 @@ const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(functio
 	};
 });
 //#endregion
-export { formatAttachmentPathLines as a, appendAttachmentPathLines as i, requireRuntimeSessionId as n, stampRuntimeEvent as r, makeManagedServerProvider as t };
+export { makeManagedServerProvider as t };

package/dist/{makeManagedServerProvider-Dy2Ny9tk.cjs → makeManagedServerProvider-DGbd8BhM.cjs}

@@ -1,46 +1,11 @@
 #!/usr/bin/env node
 
 const require_rolldown_runtime = require("./rolldown-runtime-LGfotAqq.cjs");
-require("./collectUint8StreamText-whblCEfg.cjs");
+require("./src-BlzIcnVG.cjs");
 const require_bin = require("./bin.cjs");
 let effect = require("effect");
 let effect_Semaphore = require("effect/Semaphore");
 effect_Semaphore = require_rolldown_runtime.__toESM(effect_Semaphore, 1);
-//#region ../../packages/shared/src/attachmentPrompt.ts
-function formatAttachmentPathLine(entry) {
-	const attachment = entry.attachment;
-	const name = attachment.name ?? "attachment";
-	const mimeType = attachment.mimeType ?? "unknown";
-	const sizeText = attachment.sizeBytes === void 0 ? "size unknown" : `${attachment.sizeBytes}`;
-	if (attachment.id === void 0 || entry.resolvedPath === void 0) return `[Attached file] ${name} (${mimeType}, ${sizeText} bytes)`;
-	return `[Attached file] ${name} (${mimeType}, ${sizeText} bytes) saved at: ${entry.resolvedPath}`;
-}
-function formatAttachmentPathLines(entries) {
-	return entries.map(formatAttachmentPathLine);
-}
-function appendAttachmentPathLines(text, pathLines) {
-	if (pathLines.length === 0) return text;
-	const lines = pathLines.join("\n");
-	if (text === void 0 || text.trim().length === 0) return lines;
-	return `${text}\n\n${lines}`;
-}
-//#endregion
-//#region src/provider/runtimeSession.ts
-function requireRuntimeSessionId(provider, input) {
-	return input.runtimeSessionId !== void 0 ? effect.Effect.succeed(input.runtimeSessionId) : effect.Effect.fail(new require_bin.ProviderAdapterValidationError({
-		provider,
-		operation: "startSession",
-		issue: "runtimeSessionId is required for new provider sessions."
-	}));
-}
-function stampRuntimeEvent(event, input) {
-	return {
-		...event,
-		providerInstanceId: input.providerInstanceId,
-		runtimeSessionId: input.runtimeSessionId
-	};
-}
-//#endregion
 //#region src/provider/makeManagedServerProvider.ts
 const DEFAULT_SNAPSHOT_FRESHNESS = effect.Duration.minutes(5);
 const isProviderSnapshotFresh = (input) => input.lastRefreshAttemptAtMs !== null && input.nowMs - input.lastRefreshAttemptAtMs < input.freshnessMs;
@@ -153,33 +118,9 @@ const makeManagedServerProvider = effect.Effect.fn("makeManagedServerProvider")(
 	};
 });
 //#endregion
-Object.defineProperty(exports, "appendAttachmentPathLines", {
-	enumerable: true,
-	get: function() {
-		return appendAttachmentPathLines;
-	}
-});
-Object.defineProperty(exports, "formatAttachmentPathLines", {
-	enumerable: true,
-	get: function() {
-		return formatAttachmentPathLines;
-	}
-});
 Object.defineProperty(exports, "makeManagedServerProvider", {
 	enumerable: true,
 	get: function() {
 		return makeManagedServerProvider;
 	}
 });
-Object.defineProperty(exports, "requireRuntimeSessionId", {
-	enumerable: true,
-	get: function() {
-		return requireRuntimeSessionId;
-	}
-});
-Object.defineProperty(exports, "stampRuntimeEvent", {
-	enumerable: true,
-	get: function() {
-		return stampRuntimeEvent;
-	}
-});

package/dist/runtimeSession-Bj0OUcNJ.cjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+const require_bin = require("./bin.cjs");
+let effect = require("effect");
+//#region ../../packages/shared/src/attachmentPrompt.ts
+function formatAttachmentPathLine(entry) {
+	const attachment = entry.attachment;
+	const name = attachment.name ?? "attachment";
+	const mimeType = attachment.mimeType ?? "unknown";
+	const sizeText = attachment.sizeBytes === void 0 ? "size unknown" : `${attachment.sizeBytes}`;
+	if (attachment.id === void 0 || entry.resolvedPath === void 0) return `[Attached file] ${name} (${mimeType}, ${sizeText} bytes)`;
+	return `[Attached file] ${name} (${mimeType}, ${sizeText} bytes) saved at: ${entry.resolvedPath}`;
+}
+function formatAttachmentPathLines(entries) {
+	return entries.map(formatAttachmentPathLine);
+}
+function appendAttachmentPathLines(text, pathLines) {
+	if (pathLines.length === 0) return text;
+	const lines = pathLines.join("\n");
+	if (text === void 0 || text.trim().length === 0) return lines;
+	return `${text}\n\n${lines}`;
+}
+//#endregion
+//#region src/provider/runtimeSession.ts
+function requireRuntimeSessionId(provider, input) {
+	return input.runtimeSessionId !== void 0 ? effect.Effect.succeed(input.runtimeSessionId) : effect.Effect.fail(new require_bin.ProviderAdapterValidationError({
+		provider,
+		operation: "startSession",
+		issue: "runtimeSessionId is required for new provider sessions."
+	}));
+}
+function stampRuntimeEvent(event, input) {
+	return {
+		...event,
+		providerInstanceId: input.providerInstanceId,
+		runtimeSessionId: input.runtimeSessionId
+	};
+}
+//#endregion
+Object.defineProperty(exports, "appendAttachmentPathLines", {
+	enumerable: true,
+	get: function() {
+		return appendAttachmentPathLines;
+	}
+});
+Object.defineProperty(exports, "formatAttachmentPathLines", {
+	enumerable: true,
+	get: function() {
+		return formatAttachmentPathLines;
+	}
+});
+Object.defineProperty(exports, "requireRuntimeSessionId", {
+	enumerable: true,
+	get: function() {
+		return requireRuntimeSessionId;
+	}
+});
+Object.defineProperty(exports, "stampRuntimeEvent", {
+	enumerable: true,
+	get: function() {
+		return stampRuntimeEvent;
+	}
+});

package/dist/runtimeSession-CA6cLWg0.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+import { Ht as ProviderAdapterValidationError } from "./bin.mjs";
+import { Effect } from "effect";
+//#region ../../packages/shared/src/attachmentPrompt.ts
+function formatAttachmentPathLine(entry) {
+	const attachment = entry.attachment;
+	const name = attachment.name ?? "attachment";
+	const mimeType = attachment.mimeType ?? "unknown";
+	const sizeText = attachment.sizeBytes === void 0 ? "size unknown" : `${attachment.sizeBytes}`;
+	if (attachment.id === void 0 || entry.resolvedPath === void 0) return `[Attached file] ${name} (${mimeType}, ${sizeText} bytes)`;
+	return `[Attached file] ${name} (${mimeType}, ${sizeText} bytes) saved at: ${entry.resolvedPath}`;
+}
+function formatAttachmentPathLines(entries) {
+	return entries.map(formatAttachmentPathLine);
+}
+function appendAttachmentPathLines(text, pathLines) {
+	if (pathLines.length === 0) return text;
+	const lines = pathLines.join("\n");
+	if (text === void 0 || text.trim().length === 0) return lines;
+	return `${text}\n\n${lines}`;
+}
+//#endregion
+//#region src/provider/runtimeSession.ts
+function requireRuntimeSessionId(provider, input) {
+	return input.runtimeSessionId !== void 0 ? Effect.succeed(input.runtimeSessionId) : Effect.fail(new ProviderAdapterValidationError({
+		provider,
+		operation: "startSession",
+		issue: "runtimeSessionId is required for new provider sessions."
+	}));
+}
+function stampRuntimeEvent(event, input) {
+	return {
+		...event,
+		providerInstanceId: input.providerInstanceId,
+		runtimeSessionId: input.runtimeSessionId
+	};
+}
+//#endregion
+export { formatAttachmentPathLines as i, stampRuntimeEvent as n, appendAttachmentPathLines as r, requireRuntimeSessionId as t };

package/dist/schemaJson-CaG1bOvo.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { Cause, Effect, Exit, Option, Result, Schema, SchemaGetter, SchemaIssue, SchemaTransformation } from "effect";
+//#region ../../packages/shared/src/schemaJson.ts
+const decodeJsonResult = (schema) => {
+	const decode = Schema.decodeExit(Schema.fromJsonString(schema));
+	return (input) => {
+		const result = decode(input);
+		if (Exit.isFailure(result)) return Result.fail(result.cause);
+		return Result.succeed(result.value);
+	};
+};
+const formatSchemaError = (cause) => {
+	const squashed = Cause.squash(cause);
+	return Schema.isSchemaError(squashed) ? SchemaIssue.makeFormatterDefault()(squashed.issue) : Cause.pretty(cause);
+};
+/**
+* A `Getter` that parses a lenient JSON string (tolerating trailing commas
+* and JS-style comments) into an unknown value.
+*
+* Mirrors `SchemaGetter.parseJson()` but uses `parseLenientJson` instead
+* of `JSON.parse`.
+*/
+const parseLenientJsonGetter = SchemaGetter.onSome((input) => Effect.try({
+	try: () => {
+		let stripped = input.replace(/("(?:[^"\\]|\\.)*")|\/\/[^\n]*/g, (match, stringLiteral) => stringLiteral ? match : "");
+		stripped = stripped.replace(/("(?:[^"\\]|\\.)*")|\/\*[\s\S]*?\*\//g, (match, stringLiteral) => stringLiteral ? match : "");
+		stripped = stripped.replace(/,(\s*[}\]])/g, "$1");
+		return Option.some(JSON.parse(stripped));
+	},
+	catch: (e) => new SchemaIssue.InvalidValue({ message: String(e) }, input)
+}));
+/**
+* Schema transformation: lenient JSONC string ↔ unknown.
+*
+* Same API as `SchemaTransformation.fromJsonString`, but the decode side
+* strips trailing commas and JS-style comments before parsing.
+* Encoding produces strict JSON via `JSON.stringify`.
+*/
+const fromLenientJsonString = new SchemaTransformation.Transformation(parseLenientJsonGetter, SchemaGetter.stringifyJson());
+/**
+* Build a schema that decodes a lenient JSON string into `A`.
+*
+* Drop-in replacement for `Schema.fromJsonString(schema)` that tolerates
+* trailing commas and comments in the input.
+*/
+const fromLenientJson = (schema) => Schema.String.pipe(Schema.decodeTo(schema, fromLenientJsonString));
+//#endregion
+export { formatSchemaError as n, fromLenientJson as r, decodeJsonResult as t };

package/dist/schemaJson-CuhFxa8p.cjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+let effect = require("effect");
+//#region ../../packages/shared/src/schemaJson.ts
+const decodeJsonResult = (schema) => {
+	const decode = effect.Schema.decodeExit(effect.Schema.fromJsonString(schema));
+	return (input) => {
+		const result = decode(input);
+		if (effect.Exit.isFailure(result)) return effect.Result.fail(result.cause);
+		return effect.Result.succeed(result.value);
+	};
+};
+const formatSchemaError = (cause) => {
+	const squashed = effect.Cause.squash(cause);
+	return effect.Schema.isSchemaError(squashed) ? effect.SchemaIssue.makeFormatterDefault()(squashed.issue) : effect.Cause.pretty(cause);
+};
+/**
+* A `Getter` that parses a lenient JSON string (tolerating trailing commas
+* and JS-style comments) into an unknown value.
+*
+* Mirrors `SchemaGetter.parseJson()` but uses `parseLenientJson` instead
+* of `JSON.parse`.
+*/
+const parseLenientJsonGetter = effect.SchemaGetter.onSome((input) => effect.Effect.try({
+	try: () => {
+		let stripped = input.replace(/("(?:[^"\\]|\\.)*")|\/\/[^\n]*/g, (match, stringLiteral) => stringLiteral ? match : "");
+		stripped = stripped.replace(/("(?:[^"\\]|\\.)*")|\/\*[\s\S]*?\*\//g, (match, stringLiteral) => stringLiteral ? match : "");
+		stripped = stripped.replace(/,(\s*[}\]])/g, "$1");
+		return effect.Option.some(JSON.parse(stripped));
+	},
+	catch: (e) => new effect.SchemaIssue.InvalidValue({ message: String(e) }, input)
+}));
+/**
+* Schema transformation: lenient JSONC string ↔ unknown.
+*
+* Same API as `SchemaTransformation.fromJsonString`, but the decode side
+* strips trailing commas and JS-style comments before parsing.
+* Encoding produces strict JSON via `JSON.stringify`.
+*/
+const fromLenientJsonString = new effect.SchemaTransformation.Transformation(parseLenientJsonGetter, effect.SchemaGetter.stringifyJson());
+/**
+* Build a schema that decodes a lenient JSON string into `A`.
+*
+* Drop-in replacement for `Schema.fromJsonString(schema)` that tolerates
+* trailing commas and comments in the input.
+*/
+const fromLenientJson = (schema) => effect.Schema.String.pipe(effect.Schema.decodeTo(schema, fromLenientJsonString));
+//#endregion
+Object.defineProperty(exports, "decodeJsonResult", {
+	enumerable: true,
+	get: function() {
+		return decodeJsonResult;
+	}
+});
+Object.defineProperty(exports, "formatSchemaError", {
+	enumerable: true,
+	get: function() {
+		return formatSchemaError;
+	}
+});
+Object.defineProperty(exports, "fromLenientJson", {
+	enumerable: true,
+	get: function() {
+		return fromLenientJson;
+	}
+});