ryco-cli 0.1.3 → 0.1.5

package/dist/Metrics-DNOriWhP.cjs

@@ -0,0 +1,634 @@
+#!/usr/bin/env node
+
+const require_chunk = require("./chunk-jM1PLTSZ.cjs");
+const require_sourceControl = require("./sourceControl-x2t62T8h.cjs");
+let effect_Effect = require("effect/Effect");
+effect_Effect = require_chunk.__toESM(effect_Effect, 1);
+let effect = require("effect");
+let effect_Function = require("effect/Function");
+let effect_Random = require("effect/Random");
+effect_Random = require_chunk.__toESM(effect_Random, 1);
+//#region src/config.ts
+/**
+* ServerConfig - Runtime configuration services.
+*
+* Defines process-level server configuration and networking helpers used by
+* startup and runtime layers.
+*
+* @module ServerConfig
+*/
+const DEFAULT_PORT = 3773;
+const RuntimeMode = effect.Schema.Literals(["web", "desktop"]);
+effect.Schema.Literals(["browser", "headless"]);
+const deriveServerPaths = effect.Effect.fn(function* (baseDir, devUrl) {
+	const { join } = yield* effect.Path.Path;
+	const stateDir = join(baseDir, devUrl !== void 0 ? "dev" : "userdata");
+	const dbPath = join(stateDir, "state.sqlite");
+	const attachmentsDir = join(stateDir, "attachments");
+	const logsDir = join(stateDir, "logs");
+	const providerLogsDir = join(logsDir, "provider");
+	const providerStatusCacheDir = join(baseDir, "caches");
+	return {
+		stateDir,
+		dbPath,
+		keybindingsConfigPath: join(stateDir, "keybindings.json"),
+		settingsPath: join(stateDir, "settings.json"),
+		providerStatusCacheDir,
+		worktreesDir: join(baseDir, "worktrees"),
+		attachmentsDir,
+		logsDir,
+		serverLogPath: join(logsDir, "server.log"),
+		serverTracePath: join(logsDir, "server.trace.ndjson"),
+		providerLogsDir,
+		providerEventLogPath: join(providerLogsDir, "events.log"),
+		terminalLogsDir: join(logsDir, "terminals"),
+		anonymousIdPath: join(stateDir, "anonymous-id"),
+		environmentIdPath: join(stateDir, "environment-id"),
+		serverRuntimeStatePath: join(stateDir, "server-runtime.json"),
+		secretsDir: join(stateDir, "secrets")
+	};
+});
+const ensureServerDirectories = effect.Effect.fn(function* (derivedPaths) {
+	const fs = yield* effect.FileSystem.FileSystem;
+	const path = yield* effect.Path.Path;
+	const directories = [
+		derivedPaths.stateDir,
+		derivedPaths.logsDir,
+		derivedPaths.providerLogsDir,
+		derivedPaths.terminalLogsDir,
+		derivedPaths.attachmentsDir,
+		derivedPaths.worktreesDir,
+		path.dirname(derivedPaths.keybindingsConfigPath),
+		path.dirname(derivedPaths.settingsPath),
+		derivedPaths.providerStatusCacheDir,
+		path.dirname(derivedPaths.anonymousIdPath),
+		path.dirname(derivedPaths.serverRuntimeStatePath)
+	];
+	yield* effect.Effect.all([...new Set(directories)].map((directory) => fs.makeDirectory(directory, { recursive: true })), { concurrency: "unbounded" });
+});
+/**
+* ServerConfig - Service tag for server runtime configuration.
+*/
+var ServerConfig = class ServerConfig extends effect.Context.Service()("ryco/config/ServerConfig") {
+	static layerTest = (cwd, baseDirOrPrefix) => effect.Layer.effect(ServerConfig, effect.Effect.gen(function* () {
+		const devUrl = void 0;
+		const fs = yield* effect.FileSystem.FileSystem;
+		const baseDir = typeof baseDirOrPrefix === "string" ? baseDirOrPrefix : yield* fs.makeTempDirectoryScoped({ prefix: baseDirOrPrefix.prefix });
+		const derivedPaths = yield* deriveServerPaths(baseDir, devUrl);
+		yield* ensureServerDirectories(derivedPaths);
+		return {
+			logLevel: "Error",
+			traceMinLevel: "Info",
+			traceTimingEnabled: true,
+			traceBatchWindowMs: 200,
+			traceMaxBytes: 10 * 1024 * 1024,
+			traceMaxFiles: 10,
+			otlpTracesUrl: void 0,
+			otlpMetricsUrl: void 0,
+			otlpExportIntervalMs: 1e4,
+			otlpServiceName: "ryco-server",
+			cwd,
+			baseDir,
+			...derivedPaths,
+			mode: "web",
+			autoBootstrapProjectFromCwd: false,
+			logWebSocketEvents: false,
+			tailscaleServeEnabled: false,
+			tailscaleServePort: 443,
+			port: 0,
+			host: void 0,
+			desktopBootstrapToken: void 0,
+			staticDir: void 0,
+			devUrl,
+			noBrowser: false,
+			startupPresentation: "browser"
+		};
+	}));
+};
+const resolveStaticDir = effect.Effect.fn(function* () {
+	const { join, resolve } = yield* effect.Path.Path;
+	const { exists } = yield* effect.FileSystem.FileSystem;
+	const bundledClient = resolve(join(__dirname, "client"));
+	if (yield* exists(join(bundledClient, "index.html")).pipe(effect.Effect.orElseSucceed(() => false))) return bundledClient;
+	const monorepoClient = resolve(join(__dirname, "../../web/dist"));
+	if (yield* exists(join(monorepoClient, "index.html")).pipe(effect.Effect.orElseSucceed(() => false))) return monorepoClient;
+});
+//#endregion
+//#region src/observability/Attributes.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function markSeen(value, seen) {
+	if (seen.has(value)) return true;
+	seen.add(value);
+	return false;
+}
+function normalizeJsonValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value ?? null;
+	if (typeof value === "bigint") return value.toString();
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message,
+		...value.stack ? { stack: value.stack } : {}
+	};
+	if (Array.isArray(value)) {
+		if (markSeen(value, seen)) return "[Circular]";
+		return value.map((entry) => normalizeJsonValue(entry, seen));
+	}
+	if (value instanceof Map) {
+		if (markSeen(value, seen)) return "[Circular]";
+		return Object.fromEntries(Array.from(value.entries(), ([key, entryValue]) => [String(key), normalizeJsonValue(entryValue, seen)]));
+	}
+	if (value instanceof Set) {
+		if (markSeen(value, seen)) return "[Circular]";
+		return Array.from(value.values(), (entry) => normalizeJsonValue(entry, seen));
+	}
+	if (!isPlainObject(value)) return String(value);
+	if (markSeen(value, seen)) return "[Circular]";
+	return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, normalizeJsonValue(entryValue, seen)]));
+}
+function compactTraceAttributes(attributes) {
+	return Object.fromEntries(Object.entries(attributes).filter(([, value]) => value !== void 0).map(([key, value]) => [key, normalizeJsonValue(value)]));
+}
+function compactMetricAttributes(attributes) {
+	return Object.fromEntries(Object.entries(attributes).flatMap(([key, value]) => {
+		if (value === void 0 || value === null) return [];
+		if (typeof value === "string") return [[key, value]];
+		if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return [[key, String(value)]];
+		return [];
+	}));
+}
+function outcomeFromExit(exit) {
+	if (effect.Exit.isSuccess(exit)) return "success";
+	return effect.Cause.hasInterruptsOnly(exit.cause) ? "interrupt" : "failure";
+}
+function normalizeModelMetricLabel(model) {
+	const normalized = model?.trim().toLowerCase();
+	if (!normalized) return;
+	if (normalized.includes("gpt")) return "gpt";
+	if (normalized.includes("claude")) return "claude";
+	if (normalized.includes("gemini")) return "gemini";
+	return "other";
+}
+//#endregion
+//#region ../../packages/shared/src/git.ts
+const WORKTREE_BRANCH_PREFIX = "ryco";
+const TEMP_WORKTREE_BRANCH_PATTERN = new RegExp(`^(?:${WORKTREE_BRANCH_PREFIX}|ryco)\\/[0-9a-f]{8}$`);
+/**
+* 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);
+}
+function buildTemporaryWorktreeBranchName() {
+	return `${WORKTREE_BRANCH_PREFIX}/${effect_Effect.runSync(effect_Random.nextUUIDv4).replace(/-/g, "").slice(0, 8).toLowerCase()}`;
+}
+function isTemporaryWorktreeBranch(refName) {
+	return TEMP_WORKTREE_BRANCH_PATTERN.test(refName.trim().toLowerCase());
+}
+/**
+* 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
+//#region src/observability/Metrics.ts
+const metricNames = {
+	rpcRequestsTotal: "ryco_rpc_requests_total",
+	rpcRequestDuration: "ryco_rpc_request_duration",
+	orchestrationCommandsTotal: "ryco_orchestration_commands_total",
+	orchestrationCommandDuration: "ryco_orchestration_command_duration",
+	orchestrationCommandAckDuration: "ryco_orchestration_command_ack_duration",
+	orchestrationEventsProcessedTotal: "ryco_orchestration_events_processed_total",
+	providerSessionsTotal: "ryco_provider_sessions_total",
+	providerTurnsTotal: "ryco_provider_turns_total",
+	providerTurnDuration: "ryco_provider_turn_duration",
+	providerRuntimeEventsTotal: "ryco_provider_runtime_events_total",
+	providerEventLogRecordsDroppedTotal: "ryco_provider_event_log_records_dropped_total",
+	startupCommandGateEnqueuesTotal: "ryco_startup_command_gate_enqueues_total",
+	startupCommandGateQueueDepth: "ryco_startup_command_gate_queue_depth",
+	startupCommandGateQueueHighWater: "ryco_startup_command_gate_queue_high_water",
+	startupCommandGateQueueWaitDuration: "ryco_startup_command_gate_queue_wait_duration",
+	providerStartupAdmissionTotal: "ryco_provider_startup_admission_total",
+	providerStartupQueueDepth: "ryco_provider_startup_queue_depth",
+	providerStartupQueueHighWater: "ryco_provider_startup_queue_high_water",
+	providerStartupQueueWaitDuration: "ryco_provider_startup_queue_wait_duration",
+	gitCommandsTotal: "ryco_git_commands_total",
+	gitCommandDuration: "ryco_git_command_duration",
+	terminalSessionsTotal: "ryco_terminal_sessions_total",
+	terminalRestartsTotal: "ryco_terminal_restarts_total"
+};
+const rpcRequestsTotal = effect.Metric.counter(metricNames.rpcRequestsTotal, { description: "Total RPC requests handled by the websocket RPC server." });
+const rpcRequestDuration = effect.Metric.timer(metricNames.rpcRequestDuration, { description: "RPC request handling duration." });
+const orchestrationCommandsTotal = effect.Metric.counter(metricNames.orchestrationCommandsTotal, { description: "Total orchestration commands dispatched." });
+const orchestrationCommandDuration = effect.Metric.timer(metricNames.orchestrationCommandDuration, { description: "Orchestration command dispatch duration." });
+const orchestrationCommandAckDuration = effect.Metric.timer(metricNames.orchestrationCommandAckDuration, { description: "Time from orchestration command dispatch to the first committed domain event emitted for that command." });
+const orchestrationEventsProcessedTotal = effect.Metric.counter(metricNames.orchestrationEventsProcessedTotal, { description: "Total orchestration intent events processed by runtime reactors." });
+const providerSessionsTotal = effect.Metric.counter(metricNames.providerSessionsTotal, { description: "Total provider session lifecycle operations." });
+const providerTurnsTotal = effect.Metric.counter(metricNames.providerTurnsTotal, { description: "Total provider turn lifecycle operations." });
+const providerTurnDuration = effect.Metric.timer(metricNames.providerTurnDuration, { description: "Provider turn request duration." });
+const providerRuntimeEventsTotal = effect.Metric.counter(metricNames.providerRuntimeEventsTotal, { description: "Total canonical provider runtime events processed." });
+const providerEventLogRecordsDroppedTotal = effect.Metric.counter(metricNames.providerEventLogRecordsDroppedTotal, { description: "Total provider observability log records dropped by bounded logging queues." });
+const startupCommandGateEnqueuesTotal = effect.Metric.counter(metricNames.startupCommandGateEnqueuesTotal, { description: "Total startup command gate enqueue attempts by outcome." });
+const startupCommandGateQueueDepth = effect.Metric.gauge(metricNames.startupCommandGateQueueDepth, { description: "Current number of commands waiting for startup command readiness." });
+const startupCommandGateQueueHighWater = effect.Metric.gauge(metricNames.startupCommandGateQueueHighWater, { description: "Highest observed startup command gate queue depth." });
+const startupCommandGateQueueWaitDuration = effect.Metric.timer(metricNames.startupCommandGateQueueWaitDuration, { description: "Time startup commands spent waiting for command readiness." });
+const providerStartupAdmissionTotal = effect.Metric.counter(metricNames.providerStartupAdmissionTotal, { description: "Total provider startup admission attempts by outcome." });
+const providerStartupQueueDepth = effect.Metric.gauge(metricNames.providerStartupQueueDepth, { description: "Current number of provider session starts in admission per provider instance." });
+const providerStartupQueueHighWater = effect.Metric.gauge(metricNames.providerStartupQueueHighWater, { description: "Highest observed provider startup admission depth per provider instance." });
+const providerStartupQueueWaitDuration = effect.Metric.timer(metricNames.providerStartupQueueWaitDuration, { description: "Time provider session starts spent waiting for startup admission." });
+const gitCommandsTotal = effect.Metric.counter(metricNames.gitCommandsTotal, { description: "Total git commands executed by the server runtime." });
+const gitCommandDuration = effect.Metric.timer(metricNames.gitCommandDuration, { description: "Git command execution duration." });
+const terminalSessionsTotal = effect.Metric.counter(metricNames.terminalSessionsTotal, { description: "Total terminal sessions started." });
+const terminalRestartsTotal = effect.Metric.counter(metricNames.terminalRestartsTotal, { description: "Total terminal restart requests handled." });
+const metricAttributes = (attributes) => Object.entries(compactMetricAttributes(attributes));
+const increment = (metric, attributes, amount = 1) => effect.Metric.update(effect.Metric.withAttributes(metric, metricAttributes(attributes)), amount);
+const withMetricsImpl = (effect$1, options) => effect.Effect.gen(function* () {
+	const startedAt = Date.now();
+	const exit = yield* effect.Effect.exit(effect$1);
+	const duration = effect.Duration.millis(Math.max(0, Date.now() - startedAt));
+	const baseAttributes = typeof options.attributes === "function" ? options.attributes() : options.attributes ?? {};
+	if (options.timer) yield* effect.Metric.update(effect.Metric.withAttributes(options.timer, metricAttributes(baseAttributes)), duration);
+	if (options.counter) {
+		const outcome = outcomeFromExit(exit);
+		yield* effect.Metric.update(effect.Metric.withAttributes(options.counter, metricAttributes({
+			...baseAttributes,
+			outcome,
+			...options.outcomeAttributes ? options.outcomeAttributes(outcome) : {}
+		})), 1);
+	}
+	if (effect.Exit.isSuccess(exit)) return exit.value;
+	return yield* effect.Effect.failCause(exit.cause);
+});
+const withMetrics = (0, effect_Function.dual)(2, withMetricsImpl);
+const providerMetricAttributes = (provider, extra) => compactMetricAttributes({
+	provider,
+	...extra
+});
+const providerTurnMetricAttributes = (input) => {
+	const modelFamily = normalizeModelMetricLabel(input.model);
+	return compactMetricAttributes({
+		provider: input.provider,
+		...modelFamily ? { modelFamily } : {},
+		...input.extra
+	});
+};
+//#endregion
+Object.defineProperty(exports, "DEFAULT_PORT", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_PORT;
+	}
+});
+Object.defineProperty(exports, "RuntimeMode", {
+	enumerable: true,
+	get: function() {
+		return RuntimeMode;
+	}
+});
+Object.defineProperty(exports, "ServerConfig", {
+	enumerable: true,
+	get: function() {
+		return ServerConfig;
+	}
+});
+Object.defineProperty(exports, "WORKTREE_BRANCH_PREFIX", {
+	enumerable: true,
+	get: function() {
+		return WORKTREE_BRANCH_PREFIX;
+	}
+});
+Object.defineProperty(exports, "buildTemporaryWorktreeBranchName", {
+	enumerable: true,
+	get: function() {
+		return buildTemporaryWorktreeBranchName;
+	}
+});
+Object.defineProperty(exports, "compactTraceAttributes", {
+	enumerable: true,
+	get: function() {
+		return compactTraceAttributes;
+	}
+});
+Object.defineProperty(exports, "dedupeRemoteBranchesWithLocalMatches", {
+	enumerable: true,
+	get: function() {
+		return dedupeRemoteBranchesWithLocalMatches;
+	}
+});
+Object.defineProperty(exports, "deriveServerPaths", {
+	enumerable: true,
+	get: function() {
+		return deriveServerPaths;
+	}
+});
+Object.defineProperty(exports, "detectSourceControlProviderFromGitRemoteUrl", {
+	enumerable: true,
+	get: function() {
+		return detectSourceControlProviderFromGitRemoteUrl;
+	}
+});
+Object.defineProperty(exports, "ensureServerDirectories", {
+	enumerable: true,
+	get: function() {
+		return ensureServerDirectories;
+	}
+});
+Object.defineProperty(exports, "gitCommandDuration", {
+	enumerable: true,
+	get: function() {
+		return gitCommandDuration;
+	}
+});
+Object.defineProperty(exports, "gitCommandsTotal", {
+	enumerable: true,
+	get: function() {
+		return gitCommandsTotal;
+	}
+});
+Object.defineProperty(exports, "increment", {
+	enumerable: true,
+	get: function() {
+		return increment;
+	}
+});
+Object.defineProperty(exports, "isTemporaryWorktreeBranch", {
+	enumerable: true,
+	get: function() {
+		return isTemporaryWorktreeBranch;
+	}
+});
+Object.defineProperty(exports, "mergeGitStatusParts", {
+	enumerable: true,
+	get: function() {
+		return mergeGitStatusParts;
+	}
+});
+Object.defineProperty(exports, "metricAttributes", {
+	enumerable: true,
+	get: function() {
+		return metricAttributes;
+	}
+});
+Object.defineProperty(exports, "normalizeGitRemoteUrl", {
+	enumerable: true,
+	get: function() {
+		return normalizeGitRemoteUrl;
+	}
+});
+Object.defineProperty(exports, "orchestrationCommandAckDuration", {
+	enumerable: true,
+	get: function() {
+		return orchestrationCommandAckDuration;
+	}
+});
+Object.defineProperty(exports, "orchestrationCommandDuration", {
+	enumerable: true,
+	get: function() {
+		return orchestrationCommandDuration;
+	}
+});
+Object.defineProperty(exports, "orchestrationCommandsTotal", {
+	enumerable: true,
+	get: function() {
+		return orchestrationCommandsTotal;
+	}
+});
+Object.defineProperty(exports, "orchestrationEventsProcessedTotal", {
+	enumerable: true,
+	get: function() {
+		return orchestrationEventsProcessedTotal;
+	}
+});
+Object.defineProperty(exports, "outcomeFromExit", {
+	enumerable: true,
+	get: function() {
+		return outcomeFromExit;
+	}
+});
+Object.defineProperty(exports, "providerEventLogRecordsDroppedTotal", {
+	enumerable: true,
+	get: function() {
+		return providerEventLogRecordsDroppedTotal;
+	}
+});
+Object.defineProperty(exports, "providerMetricAttributes", {
+	enumerable: true,
+	get: function() {
+		return providerMetricAttributes;
+	}
+});
+Object.defineProperty(exports, "providerRuntimeEventsTotal", {
+	enumerable: true,
+	get: function() {
+		return providerRuntimeEventsTotal;
+	}
+});
+Object.defineProperty(exports, "providerSessionsTotal", {
+	enumerable: true,
+	get: function() {
+		return providerSessionsTotal;
+	}
+});
+Object.defineProperty(exports, "providerStartupAdmissionTotal", {
+	enumerable: true,
+	get: function() {
+		return providerStartupAdmissionTotal;
+	}
+});
+Object.defineProperty(exports, "providerStartupQueueDepth", {
+	enumerable: true,
+	get: function() {
+		return providerStartupQueueDepth;
+	}
+});
+Object.defineProperty(exports, "providerStartupQueueHighWater", {
+	enumerable: true,
+	get: function() {
+		return providerStartupQueueHighWater;
+	}
+});
+Object.defineProperty(exports, "providerStartupQueueWaitDuration", {
+	enumerable: true,
+	get: function() {
+		return providerStartupQueueWaitDuration;
+	}
+});
+Object.defineProperty(exports, "providerTurnDuration", {
+	enumerable: true,
+	get: function() {
+		return providerTurnDuration;
+	}
+});
+Object.defineProperty(exports, "providerTurnMetricAttributes", {
+	enumerable: true,
+	get: function() {
+		return providerTurnMetricAttributes;
+	}
+});
+Object.defineProperty(exports, "providerTurnsTotal", {
+	enumerable: true,
+	get: function() {
+		return providerTurnsTotal;
+	}
+});
+Object.defineProperty(exports, "resolveAutoFeatureBranchName", {
+	enumerable: true,
+	get: function() {
+		return resolveAutoFeatureBranchName;
+	}
+});
+Object.defineProperty(exports, "resolveStaticDir", {
+	enumerable: true,
+	get: function() {
+		return resolveStaticDir;
+	}
+});
+Object.defineProperty(exports, "rpcRequestDuration", {
+	enumerable: true,
+	get: function() {
+		return rpcRequestDuration;
+	}
+});
+Object.defineProperty(exports, "rpcRequestsTotal", {
+	enumerable: true,
+	get: function() {
+		return rpcRequestsTotal;
+	}
+});
+Object.defineProperty(exports, "sanitizeBranchFragment", {
+	enumerable: true,
+	get: function() {
+		return sanitizeBranchFragment;
+	}
+});
+Object.defineProperty(exports, "sanitizeFeatureBranchName", {
+	enumerable: true,
+	get: function() {
+		return sanitizeFeatureBranchName;
+	}
+});
+Object.defineProperty(exports, "startupCommandGateEnqueuesTotal", {
+	enumerable: true,
+	get: function() {
+		return startupCommandGateEnqueuesTotal;
+	}
+});
+Object.defineProperty(exports, "startupCommandGateQueueDepth", {
+	enumerable: true,
+	get: function() {
+		return startupCommandGateQueueDepth;
+	}
+});
+Object.defineProperty(exports, "startupCommandGateQueueHighWater", {
+	enumerable: true,
+	get: function() {
+		return startupCommandGateQueueHighWater;
+	}
+});
+Object.defineProperty(exports, "startupCommandGateQueueWaitDuration", {
+	enumerable: true,
+	get: function() {
+		return startupCommandGateQueueWaitDuration;
+	}
+});
+Object.defineProperty(exports, "terminalRestartsTotal", {
+	enumerable: true,
+	get: function() {
+		return terminalRestartsTotal;
+	}
+});
+Object.defineProperty(exports, "terminalSessionsTotal", {
+	enumerable: true,
+	get: function() {
+		return terminalSessionsTotal;
+	}
+});
+Object.defineProperty(exports, "withMetrics", {
+	enumerable: true,
+	get: function() {
+		return withMetrics;
+	}
+});

package/dist/{NodePTY-Dg0g4rID.mjs → NodePTY-_u3kQLvd.mjs}

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 
-import { n as PtySpawnError, t as PtyAdapter } from "./bin.mjs";
+import { n as PtyAdapter, r as PtySpawnError } from "./bin.mjs";
 import { createRequire } from "node:module";
 import { Effect, FileSystem, Layer, Path } from "effect";
-
 //#region src/terminal/Layers/NodePTY.ts
 let didEnsureSpawnHelperExecutable = false;
 const resolveNodePtySpawnHelperPath = Effect.gen(function* () {
@@ -88,6 +87,5 @@ const layer = Layer.effect(PtyAdapter, Effect.gen(function* () {
 		}));
 	}) };
 }));
-
 //#endregion
-export { ensureNodePtySpawnHelperExecutable, layer };
+export { ensureNodePtySpawnHelperExecutable, layer };

package/dist/{NodePTY-U7qcu5qQ.cjs → NodePTY-keGvFYk9.cjs}

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 
-const require_bin = require('./bin.cjs');
+const require_bin = require("./bin.cjs");
 let effect = require("effect");
 let node_module = require("node:module");
-
 //#region src/terminal/Layers/NodePTY.ts
 let didEnsureSpawnHelperExecutable = false;
 const resolveNodePtySpawnHelperPath = effect.Effect.gen(function* () {
@@ -88,7 +87,6 @@ const layer = effect.Layer.effect(require_bin.PtyAdapter, effect.Effect.gen(func
 		}));
 	}) };
 }));
-
 //#endregion
 exports.ensureNodePtySpawnHelperExecutable = ensureNodePtySpawnHelperExecutable;
-exports.layer = layer;
+exports.layer = layer;