@vitest-agent/mcp 3.0.3 → 4.0.0

package/utils/crash-guards.js

@@ -1,27 +1,5 @@
 //#region src/utils/crash-guards.ts
 /**
-* Pure decision logic backing `bin.ts`'s `process.on("uncaughtException")`
-* guard (issue #191, sub-item A).
-*
-* Node's own guidance for `uncaughtException` is "do not resume normal
-* operation" because arbitrary in-process state may be corrupt. This
-* package accepts that residual risk *after* the stdio transport is
-* connected: it holds no long-lived mutable state outside SQLite
-* itself (every `DataStore`/`DataReader` call is a self-contained
-* transaction via the shared `ManagedRuntime`), so a synchronous throw
-* that escapes even the MCP SDK's own per-tool-call try/catch cannot
-* leave this process's own bookkeeping half-mutated in a way that
-* would corrupt the *next* call — and the alternative, silent process
-* death mid-TDD-session (deregistering every tool from the client), is
-* strictly worse for a long-running dev tool.
-*
-* Before the transport connects there is no client session to
-* preserve by staying alive, so failing fast and loud is the better
-* default rather than spinning forever in a half-initialized state.
-*
-* @packageDocumentation
-*/
-/**
 * @param transportConnected - whether `server.connect(transport)` has
 *   already resolved for this process
 * @returns `true` when the process should exit rather than continue

package/utils/replay-marker.js

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+
+//#region src/utils/replay-marker.ts
+/**
+* Fields to spread into a replayable success struct.
+*
+* @public
+*/
+const IdempotentReplayMarker = { _idempotentReplay: Schema.optionalKey(Schema.Literal(true)).annotate({ description: "Present (true) when this response was replayed from the idempotency cache instead of re-running the mutation." }) };
+
+//#endregion
+export { IdempotentReplayMarker };

package/utils/safe-format-fatal-error.js

@@ -2,22 +2,6 @@ import { formatFatalError } from "@vitest-agent/sdk";
 
 //#region src/utils/safe-format-fatal-error.ts
 /**
-* Crash-handler-safe wrapper around `@vitest-agent/sdk`'s
-* {@link formatFatalError}.
-*
-* `bin.ts`'s `unhandledRejection` / `uncaughtException` handlers exist so
-* a stray throw cannot kill a live MCP session (issue #191). Calling the
-* formatter directly from inside them reopened exactly that hole:
-* `formatFatalError` introspects the value it is given — `Symbol.for(...)
-* in reason`, `err instanceof Error`, `JSON.stringify(err)` — and every
-* one of those is hijackable by a `Proxy` whose `has` / `getPrototypeOf`
-* / `get` trap throws. A throw *inside* an `uncaughtException` handler is
-* fatal to the process with no second chance to report it, so the crash
-* guard would have crashed the process it exists to protect (issue #243).
-*
-* @packageDocumentation
-*/
-/**
 * Fixed fallback emitted when the formatter itself throws. Deliberately a
 * constant: anything derived from the offending value could throw again
 * on the recovery path.

package/utils/tool-error-envelope.js

@@ -35,9 +35,9 @@ function coerceThrownMessage(err) {
 }
 /**
 * Builds the structured envelope a tool's catch-all wrapper returns
-* when its resolver throws unexpectedly.
+* when its handler throws unexpectedly.
 *
-* @param toolName - the MCP tool name under which the resolver was registered
+* @param toolName - the MCP tool name under which the handler was registered
 * @param err - the value thrown or the rejection reason
 * @public
 */
@@ -51,7 +51,7 @@ function buildUnexpectedToolErrorEnvelope(toolName, err) {
 			remediation: {
 				suggestedTool: toolName,
 				suggestedArgs: {},
-				humanHint: `The "${toolName}" tool's resolver threw before producing a result (unrelated to your input in most cases). Retry the call; if it persists, check the MCP server's stderr for the logged error.`
+				humanHint: `The "${toolName}" tool's handler threw before producing a result (unrelated to your input in most cases). Retry the call; if it persists, check the MCP server's stderr for the logged error.`
 			}
 		}
 	};

package/version.js

@@ -0,0 +1,13 @@
+//#region src/version.ts
+/**
+* The version of this package, inlined at build time from
+* `package.json#version` via the bundler's `__PACKAGE_VERSION__` substitution.
+* Exported for version introspection by downstream tooling, and consumed by
+* `main.ts` to back the advertised `serverInfo.version`.
+*
+* @public
+*/
+const CURRENT_MCP_VERSION = "4.0.0";
+
+//#endregion
+export { CURRENT_MCP_VERSION };

package/layers/McpLive.js

@@ -1,29 +0,0 @@
-import { Layer } from "effect";
-import * as NodeServices from "@effect/platform-node/NodeServices";
-import { layer } from "@effect/sql-sqlite-node/SqliteClient";
-import * as SqliteMigrator from "@effect/sql-sqlite-node/SqliteMigrator";
-import { DataReaderLive, DataStoreLive, LoggerLive, OutputPipelineLive, PROJECT_MIGRATIONS, ProjectDiscoveryLive } from "@vitest-agent/sdk";
-
-//#region src/layers/McpLive.ts
-/**
-* Builds the Effect Layer that provides all services required by the MCP server.
-*
-* Composes DataReader, DataStore, ProjectDiscovery, OutputPipeline, SQLite
-* client, migrator, NodeServices, and the logger into a single
-* layer suitable for `ManagedRuntime.make`.
-*
-* @param dbPath - absolute path to the SQLite database file
-* @param logLevel - optional log level; defaults to the logger's own default
-* @param logFile - optional path to write structured log output
-* @returns an Effect Layer providing all MCP runtime services
-* @public
-*/
-const McpLive = (dbPath, logLevel, logFile) => {
-	const SqliteLayer = layer({ filename: dbPath });
-	const PlatformLayer = NodeServices.layer;
-	const MigratorLayer = SqliteMigrator.layer({ loader: SqliteMigrator.fromRecord(PROJECT_MIGRATIONS) }).pipe(Layer.provide(Layer.merge(SqliteLayer, PlatformLayer)));
-	return Layer.mergeAll(DataReaderLive, DataStoreLive, ProjectDiscoveryLive, OutputPipelineLive).pipe(Layer.provideMerge(MigratorLayer), Layer.provideMerge(SqliteLayer), Layer.provideMerge(PlatformLayer), Layer.provideMerge(LoggerLive(logLevel, logFile)));
-};
-
-//#endregion
-export { McpLive };

package/prompts/index.js

@@ -1,89 +0,0 @@
-import { explainFailurePrompt } from "./explain-failure.js";
-import { regressionSincePassPrompt } from "./regression-since-pass.js";
-import { tddResumePrompt } from "./tdd-resume.js";
-import { triagePrompt } from "./triage.js";
-import { whyFlakyPrompt } from "./why-flaky.js";
-import { wrapupPrompt } from "./wrapup.js";
-import { z } from "zod";
-
-//#region src/prompts/index.ts
-function toMessages(messages) {
-	return messages.map((m) => ({
-		role: m.role,
-		content: {
-			type: "text",
-			text: m.content.text
-		}
-	}));
-}
-function registerAllPrompts(server) {
-	server.registerPrompt("triage", {
-		title: "Triage Recent Failures",
-		description: "Orient toward a triage workflow over the most recent test run; compose triage_brief, failure_signature_get, hypothesis_record.",
-		argsSchema: { project: z.optional(z.string()).describe("Filter to a specific project") }
-	}, (args) => {
-		return { messages: toMessages(triagePrompt(args.project !== void 0 ? { project: args.project } : {}).messages) };
-	});
-	server.registerPrompt("why-flaky", {
-		title: "Diagnose a Flaky Test",
-		description: "Diagnose why a named test is flaky; compose test_history and failure_signature_get with timing/shared-state framing.",
-		argsSchema: {
-			test: z.string().describe("Full hierarchical test name (e.g. 'Suite > nested > test')"),
-			project: z.optional(z.string()).describe("Filter to a specific project")
-		}
-	}, (args) => {
-		return { messages: toMessages(whyFlakyPrompt(args.project !== void 0 ? {
-			test: args.test,
-			project: args.project
-		} : { test: args.test }).messages) };
-	});
-	server.registerPrompt("regression-since-pass", {
-		title: "Find What Broke a Test",
-		description: "Walk back from the test's most recent passing run to identify the change that broke it; compose test_history, commit_changes, turn_search.",
-		argsSchema: {
-			test: z.string().describe("Full hierarchical test name"),
-			project: z.optional(z.string()).describe("Filter to a specific project")
-		}
-	}, (args) => {
-		return { messages: toMessages(regressionSincePassPrompt(args.project !== void 0 ? {
-			test: args.test,
-			project: args.project
-		} : { test: args.test }).messages) };
-	});
-	server.registerPrompt("explain-failure", {
-		title: "Explain a Failure Class",
-		description: "Synthesize a root-cause explanation from the recurrence history of a failure signature.",
-		argsSchema: { signature: z.string().describe("16-char failure signature hex") }
-	}, (args) => {
-		return { messages: toMessages(explainFailurePrompt({ signature: args.signature }).messages) };
-	});
-	server.registerPrompt("tdd-resume", {
-		title: "Resume TDD Work",
-		description: "Resume the active TDD task from its current phase; iron-law reminder for evidence-bound transitions.",
-		argsSchema: { sessionId: z.optional(z.string()).describe("Host session id (defaults to MCP server's recovered SessionContext)") }
-	}, (args) => {
-		return { messages: toMessages(tddResumePrompt(args.sessionId !== void 0 ? { sessionId: args.sessionId } : {}).messages) };
-	});
-	server.registerPrompt("wrapup", {
-		title: "Generate a Session Wrapup",
-		description: "Surface the same wrapup content the post-hooks emit automatically.",
-		argsSchema: {
-			kind: z.optional(z.enum([
-				"stop",
-				"session_end",
-				"pre_compact",
-				"tdd_handoff",
-				"user_prompt_nudge"
-			])).describe("Wrapup variant (default: user_prompt_nudge)"),
-			since: z.optional(z.string()).describe("ISO 8601 timestamp lower bound for activity to summarize")
-		}
-	}, (args) => {
-		const wrapupArgs = {};
-		if (args.kind !== void 0) wrapupArgs.kind = args.kind;
-		if (args.since !== void 0) wrapupArgs.since = args.since;
-		return { messages: toMessages(wrapupPrompt(wrapupArgs).messages) };
-	});
-}
-
-//#endregion
-export { registerAllPrompts };

package/router.js

@@ -1,74 +0,0 @@
-import { router } from "./context.js";
-import { acceptanceMetrics } from "./tools/acceptance-metrics.js";
-import { cacheHealth } from "./tools/cache-health.js";
-import { commitChanges } from "./tools/commit-changes.js";
-import { configure } from "./tools/configure.js";
-import { testCoverage } from "./tools/coverage.js";
-import { testErrors } from "./tools/errors.js";
-import { failureSignatureGet } from "./tools/failure-signature-get.js";
-import { fileCoverage } from "./tools/file-coverage.js";
-import { help } from "./tools/help.js";
-import { testHistory } from "./tools/history.js";
-import { hypothesis } from "./tools/hypothesis.js";
-import { inventory } from "./tools/inventory.js";
-import { note } from "./tools/note.js";
-import { testOverview } from "./tools/overview.js";
-import { ping } from "./tools/ping.js";
-import { registerAgent } from "./tools/register-agent.js";
-import { runTests } from "./tools/run-tests.js";
-import { settingsList } from "./tools/settings-list.js";
-import { testStatus } from "./tools/status.js";
-import { tddArtifactList } from "./tools/tdd-artifact.js";
-import { tddBehavior } from "./tools/tdd-behavior.js";
-import { tddGoal } from "./tools/tdd-goal.js";
-import { tddPhaseTransitionRequest } from "./tools/tdd-phase-transition-request.js";
-import { tddTask } from "./tools/tdd-task.js";
-import { test } from "./tools/test.js";
-import { testTrends } from "./tools/trends.js";
-import { triageBrief } from "./tools/triage-brief.js";
-import { turnSearch } from "./tools/turn-search.js";
-import { wrapupPrompt } from "./tools/wrapup-prompt.js";
-
-//#region src/router.ts
-/**
-* The tRPC router aggregating all MCP tool procedures.
-*
-* Pass to `createCallerFactory` in tests, or to `createCallerFactory(appRouter)`
-* followed by `startMcpServer` in the bin entry to start the MCP server.
-*
-* @public
-*/
-const appRouter = router({
-	help,
-	test_status: testStatus,
-	test_overview: testOverview,
-	test_coverage: testCoverage,
-	test_history: testHistory,
-	test_trends: testTrends,
-	test_errors: testErrors,
-	test,
-	file_coverage: fileCoverage,
-	run_tests: runTests,
-	register_agent: registerAgent,
-	cache_health: cacheHealth,
-	configure,
-	inventory,
-	settings_list: settingsList,
-	note,
-	turn_search: turnSearch,
-	failure_signature_get: failureSignatureGet,
-	tdd_task: tddTask,
-	tdd_phase_transition_request: tddPhaseTransitionRequest,
-	tdd_goal: tddGoal,
-	tdd_behavior: tddBehavior,
-	tdd_artifact_list: tddArtifactList,
-	hypothesis,
-	acceptance_metrics: acceptanceMetrics,
-	triage_brief: triageBrief,
-	wrapup_prompt: wrapupPrompt,
-	commit_changes: commitChanges,
-	ping
-});
-
-//#endregion
-export { appRouter };

package/session-env.js

@@ -1,112 +0,0 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-
-//#region src/session-env.ts
-/**
-* Call-time SessionContext recovery from the per-session env files the
-* plugin's SessionStart hook writes to `~/.claude/session-env/`.
-*
-* The boot-time env recovery (`sessionContextFromEnv`) depends on Claude
-* Code auto-sourcing `CLAUDE_ENV_FILE` into the MCP child — which loses
-* two races:
-*
-* 1. **Boot race.** On a fresh Claude Code launch the MCP child can spawn
-*    before the SessionStart hook has written `CLAUDE_ENV_FILE`, so the
-*    child's `process.env` never carries the canonical UUIDs (observed
-*    live: MCP spawn at 00:41:50, env file written 00:41:51).
-* 2. **`/reload-plugins`.** A plugin reload restarts the MCP server
-*    mid-session with a fresh environment that has no session exports.
-*
-* In both cases the SessionStart hook has (or will have) written the same
-* exports to a second, known-name surface:
-* `~/.claude/session-env/<chat_id>/vitest-agent-hook.sh`. This module
-* reads that surface directly, so a null boot context can be recovered
-* lazily at the first tool call that needs it.
-*
-* Selection rule: among all session dirs whose exports name this server's
-* `projectDir`, the newest-mtime file wins — the most recently started
-* session for this project. With two live Claude Code windows on the same
-* project this can name the other window's session; that ambiguity is
-* inherent to a per-project (not per-process) surface and is accepted —
-* the pre-existing alternative was no attribution at all.
-*
-* @packageDocumentation
-*/
-const EXPORT_LINE = /^export ([A-Z_][A-Z0-9_]*)=(.*)$/;
-/**
-* Undo the `printf '%q'` quoting the SessionStart hook applies to export
-* values. UUIDs and plain paths arrive bare; values with specials arrive
-* as `$'...'`, `'...'`, `"..."`, or backslash-escaped words.
-*/
-const unquote = (raw) => {
-	let v = raw.trim();
-	if (v.startsWith("$'") && v.endsWith("'") && v.length >= 3) v = v.slice(2, -1);
-	else if (v.startsWith("'") && v.endsWith("'") || v.startsWith("\"") && v.endsWith("\"")) {
-		if (v.length >= 2) v = v.slice(1, -1);
-	}
-	return v.replace(/\\(.)/g, "$1");
-};
-/**
-* Parse `export KEY=value` lines from a session-env hook file into a
-* plain record. Non-export lines are ignored.
-*
-* @param content - the raw text of a session-env hook file
-* @returns a record of export names to unquoted values
-* @public
-*/
-const parseSessionEnvExports = (content) => {
-	const out = {};
-	for (const line of content.split("\n")) {
-		const m = EXPORT_LINE.exec(line.trim());
-		if (m?.[1] !== void 0 && m[2] !== void 0) out[m[1]] = unquote(m[2]);
-	}
-	return out;
-};
-/**
-* Recover a {@link SessionContext} from the newest session-env hook file
-* whose `VITEST_AGENT_PROJECT_DIR` matches `projectDir`.
-*
-* Returns `null` when the session-env root is missing, unreadable, or no
-* session dir matches the project. Never throws — recovery is best-effort
-* and callers fall back to their existing null-context behavior.
-*
-* @param opts - `projectDir` to match against; `sessionEnvRoot` overrides
-*   the default `~/.claude/session-env` (tests)
-* @public
-*/
-const recoverSessionContextFromSessionEnv = (opts) => {
-	const root = opts.sessionEnvRoot ?? join(homedir(), ".claude", "session-env");
-	const wantDir = resolve(opts.projectDir);
-	let entries;
-	try {
-		entries = readdirSync(root);
-	} catch {
-		return null;
-	}
-	let best = null;
-	for (const entry of entries) {
-		const file = join(root, entry, "vitest-agent-hook.sh");
-		try {
-			const st = statSync(file);
-			const env = parseSessionEnvExports(readFileSync(file, "utf8"));
-			const chatId = env.VITEST_AGENT_CHAT_ID;
-			const conversationId = env.VITEST_AGENT_CONVERSATION_ID;
-			const mainAgentId = env.VITEST_AGENT_MAIN_AGENT_ID ?? env.VITEST_AGENT_AGENT_ID;
-			const fileProjectDir = env.VITEST_AGENT_PROJECT_DIR;
-			if (chatId === void 0 || chatId.length === 0 || conversationId === void 0 || conversationId.length === 0 || mainAgentId === void 0 || mainAgentId.length === 0 || fileProjectDir === void 0 || resolve(fileProjectDir) !== wantDir) continue;
-			if (best === null || st.mtimeMs > best.mtimeMs) best = {
-				mtimeMs: st.mtimeMs,
-				ctx: {
-					chatId,
-					conversationId,
-					mainAgentId
-				}
-			};
-		} catch {}
-	}
-	return best === null ? null : best.ctx;
-};
-
-//#endregion
-export { parseSessionEnvExports, recoverSessionContextFromSessionEnv };

package/utils/effect-to-zod.js

@@ -1,158 +0,0 @@
-import { Schema } from "effect";
-import { z } from "zod";
-
-//#region src/utils/effect-to-zod.ts
-/**
-* Bridge an Effect Schema to a zod schema by routing through JSON
-* Schema. Used at the MCP `registerTool` boundary so a tool can keep
-* Effect Schema as the canonical source of truth for its output shape
-* while the SDK still receives the zod instance it expects in the
-* `outputSchema` field.
-*
-* @packageDocumentation
-*/
-/**
-* Convert an Effect `Schema.Codec<A, I>` to a zod schema by
-* serializing it to JSON Schema (`Schema.toJsonSchemaDocument`) and ingesting the
-* result via zod 4's `z.fromJSONSchema`.
-*
-* Trade-offs:
-*   - Effect-Schema-only refinements (custom predicates, Brand types)
-*     erase to plain JSON Schema primitives during the round-trip,
-*     so the resulting zod schema does not enforce them. Tools that
-*     need refinement enforcement at the MCP boundary should declare
-*     zod directly.
-*   - `Schema.NullOr(...)` round-trips correctly via JSON Schema's
-*     `oneOf` / nullable representation that zod understands.
-*   - `z.fromJSONSchema` is marked experimental in zod 4. The bridge
-*     contains a smoke-test in the corresponding test file so an
-*     incompatible upgrade surfaces immediately instead of in
-*     production tool registrations.
-*
-* Implementation note: zod 4's `z.fromJSONSchema` does not resolve
-* `$ref` lookups into `$defs` — every `{ $ref: "#/$defs/X" }` it
-* encounters throws "Reference not found". Effect's `Schema.toJsonSchemaDocument`
-* emits a `$ref`-and-`$defs` representation whenever a Schema carries
-* an `identifier` annotation. The bridge therefore inlines every
-* `$ref` in the document before handing it to zod (recursive
-* substitution, then drop `$defs`). The schemas don't use
-* `Schema.suspend`, so the substitution is acyclic.
-*
-* Annotation lifting: Effect lowers a checked numeric schema
-* (`Schema.Finite`, `Schema.Int`) to `{ type, allOf: [{ description }] }`
-* rather than putting the annotation on the node itself, and
-* `z.fromJSONSchema` preserves that nesting verbatim. A tool's
-* `outputSchema` would then advertise no description for the field. The
-* bridge therefore lifts annotation-only `allOf` members onto their
-* parent before handing the document to zod. Only the JSON Schema
-* annotation vocabulary is lifted -- a member carrying any constraint
-* keyword (`pattern`, `minimum`, ...) stays put so validation semantics
-* are never changed.
-*
-* MCP SDK constraint: `outputSchema` must normalise to a Zod object
-* schema (`normalizeObjectSchema` returns `undefined` for unions, then
-* `safeParseAsync(undefined, ...)` crashes with "Cannot read properties
-* of undefined (reading '_zod')"). When the resulting zod schema is not
-* object-typed (e.g. came from `Schema.Union` of discriminated
-* variants), the bridge wraps it in a permissive `z.object({}).catchall(z.unknown())`
-* so the SDK accepts it. The structured content the tool emits still
-* conforms to the original Effect Schema; consumers just don't get a
-* rich JSON Schema for the union in the tool listing. Restructure the
-* source schema as a single `Schema.Struct` with a discriminator field
-* if the rich listing matters.
-*/
-const effectToZodSchema = (schema) => {
-	const document = Schema.toJsonSchemaDocument(schema);
-	const jsonSchema = {
-		...document.schema,
-		$defs: document.definitions
-	};
-	const inlined = inlineAllRefs(jsonSchema);
-	const zodSchema = z.fromJSONSchema(inlined);
-	if (isObjectLike(zodSchema)) return zodSchema;
-	return z.object({}).catchall(z.unknown());
-};
-const isObjectLike = (schema) => {
-	const def = schema._zod?.def;
-	return def?.type === "object" || def?.shape !== void 0;
-};
-const REF_PREFIX = "#/$defs/";
-/**
-* The JSON Schema annotation vocabulary -- keywords that describe a
-* schema without constraining what it accepts. Only these are safe to
-* hoist out of an `allOf` member onto the parent node.
-*/
-const ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
-	"title",
-	"description",
-	"examples",
-	"default",
-	"deprecated",
-	"readOnly",
-	"writeOnly",
-	"contentEncoding",
-	"contentMediaType"
-]);
-const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-/**
-* Hoist the annotation keywords out of every `allOf` member onto
-* `node`, leaving each member's constraint keywords exactly where they
-* were. A member reduced to nothing is dropped, and `allOf` disappears
-* once every member has been consumed.
-*
-* Keys already present on the node win -- a nested annotation never
-* overwrites a more specific one -- and the first member to supply a
-* given key wins among siblings.
-*/
-const liftAnnotations = (node) => {
-	const members = node.allOf;
-	if (!Array.isArray(members)) return node;
-	const kept = [];
-	const lifted = {};
-	for (const member of members) {
-		if (!isPlainObject(member)) {
-			kept.push(member);
-			continue;
-		}
-		const constraints = {};
-		for (const [key, value] of Object.entries(member)) if (!ANNOTATION_KEYWORDS.has(key)) constraints[key] = value;
-		else if (!(key in node) && !(key in lifted)) lifted[key] = value;
-		if (Object.keys(constraints).length > 0) kept.push(constraints);
-	}
-	if (Object.keys(lifted).length === 0) return node;
-	const out = {
-		...node,
-		...lifted
-	};
-	if (kept.length > 0) out.allOf = kept;
-	else delete out.allOf;
-	return out;
-};
-/**
-* Walk a JSON Schema tree and replace every `$ref: "#/$defs/X"` node
-* with the contents of `$defs.X`, recursively. The `$defs` table is
-* dropped from the returned root.
-*/
-const inlineAllRefs = (root) => {
-	const defs = root.$defs ?? {};
-	const visit = (value) => {
-		if (Array.isArray(value)) return value.map(visit);
-		if (value === null || typeof value !== "object") return value;
-		const obj = value;
-		if (typeof obj.$ref === "string" && obj.$ref.startsWith(REF_PREFIX)) {
-			const defName = obj.$ref.slice(8);
-			const target = defs[defName];
-			if (target !== void 0) return visit(target);
-		}
-		const out = {};
-		for (const [k, v] of Object.entries(obj)) {
-			if (k === "$defs") continue;
-			out[k] = visit(v);
-		}
-		return liftAnnotations(out);
-	};
-	return visit(root);
-};
-
-//#endregion
-export { effectToZodSchema };