@dexto/core 1.1.9 → 1.1.11

package/dist/utils/execution-context.d.ts

@@ -1,21 +1,20 @@
-type ExecutionContext = 'dexto-source' | 'dexto-project' | 'global-cli';
+export type ExecutionContext = 'dexto-source' | 'dexto-project' | 'global-cli';
 /**
  * Find dexto source root directory
  * @param startPath Starting directory path
  * @returns Dexto source root directory or null if not found
  */
-declare function findDextoSourceRoot(startPath?: string): string | null;
+export declare function findDextoSourceRoot(startPath?: string): string | null;
 /**
  * Find dexto project root directory (projects using dexto as dependency)
  * @param startPath Starting directory path
  * @returns Dexto project root directory or null if not found
  */
-declare function findDextoProjectRoot(startPath?: string): string | null;
+export declare function findDextoProjectRoot(startPath?: string): string | null;
 /**
  * Detect current execution context - standardized across codebase
  * @param startPath Starting directory path (defaults to process.cwd())
  * @returns Execution context
  */
-declare function getExecutionContext(startPath?: string): ExecutionContext;
-
-export { type ExecutionContext, findDextoProjectRoot, findDextoSourceRoot, getExecutionContext };
+export declare function getExecutionContext(startPath?: string): ExecutionContext;
+//# sourceMappingURL=execution-context.d.ts.map

package/dist/utils/execution-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-context.d.ts","sourceRoot":"","sources":["../../src/utils/execution-context.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG,eAAe,GAAG,YAAY,CAAC;AAgD/E;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAEpF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAErF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,GAAE,MAAsB,GAAG,gBAAgB,CAavF"}

package/dist/utils/fs-walk.d.ts

@@ -4,6 +4,5 @@
  * @param predicate Function that returns true when the desired condition is found
  * @returns The directory path where the condition was met, or null if not found
  */
-declare function walkUpDirectories(startPath: string, predicate: (dirPath: string) => boolean): string | null;
-
-export { walkUpDirectories };
+export declare function walkUpDirectories(startPath: string, predicate: (dirPath: string) => boolean): string | null;
+//# sourceMappingURL=fs-walk.d.ts.map

package/dist/utils/fs-walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-walk.d.ts","sourceRoot":"","sources":["../../src/utils/fs-walk.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,GACxC,MAAM,GAAG,IAAI,CAef"}

package/dist/utils/index.cjs

@@ -27,6 +27,7 @@ __reExport(utils_exports, require("./execution-context.js"), module.exports);
 __reExport(utils_exports, require("./fs-walk.js"), module.exports);
 __reExport(utils_exports, require("./redactor.js"), module.exports);
 __reExport(utils_exports, require("./api-key-store.js"), module.exports);
+__reExport(utils_exports, require("./debug.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./path.js"),
@@ -40,5 +41,6 @@ __reExport(utils_exports, require("./api-key-store.js"), module.exports);
   ...require("./execution-context.js"),
   ...require("./fs-walk.js"),
   ...require("./redactor.js"),
-  ...require("./api-key-store.js")
+  ...require("./api-key-store.js"),
+  ...require("./debug.js")
 });

package/dist/utils/index.d.ts

@@ -1,63 +1,14 @@
-export { copyDirectory, ensureDextoGlobalDirectory, findPackageRoot, getDextoEnvPath, getDextoGlobalPath, getDextoPath, isPath, resolveBundledScript } from './path.js';
-export { AgentServices, createAgentServices } from './service-initializer.js';
-export { PROVIDER_API_KEY_MAP, getPrimaryApiKeyEnvVar, resolveApiKeyForProvider } from './api-key-resolver.js';
-export { getZodTypeFromProperty, jsonSchemaToZodShape } from './zod-schema-converter.js';
-export { EnvExpandedString, NonEmptyEnvExpandedString, NonEmptyTrimmed, OptionalURL, RequiredEnvURL, Result, fail, hasErrors, ok, splitIssues, zodToIssues } from './result.js';
-export { toError } from './error-conversion.js';
-export { getPort } from './port-utils.js';
-export { applyLayeredEnvironmentLoading, loadEnvironmentVariables, updateEnvFile } from './env.js';
-export { ExecutionContext, findDextoProjectRoot, findDextoSourceRoot, getExecutionContext } from './execution-context.js';
-export { walkUpDirectories } from './fs-walk.js';
-export { redactSensitiveData } from './redactor.js';
-export { getProviderKeyStatus, listProviderKeyStatus, saveProviderApiKey } from './api-key-store.js';
-import '../mcp/manager.js';
-import '../mcp/schemas.js';
-import 'zod';
-import '../mcp/types.js';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '../tools/types.js';
-import 'json-schema';
-import '@modelcontextprotocol/sdk/types.js';
-import '../tools/tool-manager.js';
-import '../tools/internal-tools/registry.js';
-import '../search/search-service.js';
-import '../storage/backend/database-backend.js';
-import '../search/types.js';
-import '../context/types.js';
-import '../llm/types.js';
-import '../tools/schemas.js';
-import '../tools/confirmation/types.js';
-import '../tools/confirmation/allowed-tools-provider/types.js';
-import '../systemPrompt/manager.js';
-import '../systemPrompt/schemas.js';
-import '../systemPrompt/types.js';
-import '../agent/state-manager.js';
-import '../agent/schemas.js';
-import '../llm/schemas.js';
-import '../events/index.js';
-import 'events';
-import '../storage/backend/types.js';
-import '../storage/backend/cache-backend.js';
-import '../storage/schemas.js';
-import '../session/session-manager.js';
-import '../session/chat-session.js';
-import '../context/manager.js';
-import '../llm/formatters/types.js';
-import '../llm/tokenizer/types.js';
-import '../context/compression/types.js';
-import '../session/history/types.js';
-import '../llm/services/types.js';
-import 'ai';
-import '../storage/storage-manager.js';
-import '../errors/types.js';
-import '../agent/error-codes.js';
-import '../config/error-codes.js';
-import '../context/error-codes.js';
-import '../llm/error-codes.js';
-import '../mcp/error-codes.js';
-import '../session/error-codes.js';
-import '../storage/error-codes.js';
-import '../systemPrompt/error-codes.js';
-import '../tools/error-codes.js';
-import '../preferences/error-codes.js';
-import '../agent/registry/error-codes.js';
+export * from './path.js';
+export * from './service-initializer.js';
+export * from './api-key-resolver.js';
+export * from './zod-schema-converter.js';
+export * from './result.js';
+export * from './error-conversion.js';
+export * from './port-utils.js';
+export * from './env.js';
+export * from './execution-context.js';
+export * from './fs-walk.js';
+export * from './redactor.js';
+export * from './api-key-store.js';
+export * from './debug.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC"}

package/dist/utils/index.js

@@ -10,3 +10,4 @@ export * from "./execution-context.js";
 export * from "./fs-walk.js";
 export * from "./redactor.js";
 export * from "./api-key-store.js";
+export * from "./debug.js";

package/dist/utils/path.d.ts

@@ -5,7 +5,7 @@
  * @param startPath Starting directory for project detection
  * @returns Absolute path to the requested location
  */
-declare function getDextoPath(type: string, filename?: string, startPath?: string): string;
+export declare function getDextoPath(type: string, filename?: string, startPath?: string): string;
 /**
  * Global path resolver that ALWAYS returns paths in the user's home directory
  * Used for agent registry and other global-only resources that should not be project-relative
@@ -13,35 +13,35 @@ declare function getDextoPath(type: string, filename?: string, startPath?: strin
  * @param filename Optional filename to append
  * @returns Absolute path to the global location (~/.dexto/...)
  */
-declare function getDextoGlobalPath(type: string, filename?: string): string;
+export declare function getDextoGlobalPath(type: string, filename?: string): string;
 /**
  * Copy entire directory recursively
  * @param src Source directory path
  * @param dest Destination directory path
  */
-declare function copyDirectory(src: string, dest: string): Promise<void>;
+export declare function copyDirectory(src: string, dest: string): Promise<void>;
 /**
  * Check if string looks like a file path vs registry name
  * @param str String to check
  * @returns True if looks like a path, false if looks like a registry name
  */
-declare function isPath(str: string): boolean;
+export declare function isPath(str: string): boolean;
 /**
  * Find package root (for other utilities)
  * @param startPath Starting directory path
  * @returns Directory containing package.json or null
  */
-declare function findPackageRoot(startPath?: string): string | null;
+export declare function findPackageRoot(startPath?: string): string | null;
 /**
  * Resolve bundled script paths for MCP servers
  * @param scriptPath Relative script path
  * @returns Absolute path to bundled script
  */
-declare function resolveBundledScript(scriptPath: string): string;
+export declare function resolveBundledScript(scriptPath: string): string;
 /**
  * Ensure ~/.dexto directory exists for global storage
  */
-declare function ensureDextoGlobalDirectory(): Promise<void>;
+export declare function ensureDextoGlobalDirectory(): Promise<void>;
 /**
  * Get the appropriate .env file path for saving API keys.
  * Uses the same project detection logic as other dexto paths.
@@ -49,6 +49,5 @@ declare function ensureDextoGlobalDirectory(): Promise<void>;
  * @param startPath Starting directory for project detection
  * @returns Absolute path to .env file for saving
  */
-declare function getDextoEnvPath(startPath?: string): string;
-
-export { copyDirectory, ensureDextoGlobalDirectory, findPackageRoot, getDextoEnvPath, getDextoGlobalPath, getDextoPath, isPath, resolveBundledScript };
+export declare function getDextoEnvPath(startPath?: string): string;
+//# sourceMappingURL=path.d.ts.map

package/dist/utils/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/utils/path.ts"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAgCxF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAI1E;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAe5E;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAW3C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAKhF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAwD/D;AAED;;GAEG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC,CAUhE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,CA2BzE"}

package/dist/utils/port-utils.d.ts

@@ -6,6 +6,5 @@
  * @returns a valid port number
  * @throws if envVar is set but not a valid port number
  */
-declare function getPort(envVar: string | undefined, defaultPort: number, varName: string): number;
-
-export { getPort };
+export declare function getPort(envVar: string | undefined, defaultPort: number, varName: string): number;
+//# sourceMappingURL=port-utils.d.ts.map

package/dist/utils/port-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port-utils.d.ts","sourceRoot":"","sources":["../../src/utils/port-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAShG"}

package/dist/utils/redactor.d.ts

@@ -13,6 +13,5 @@
  * @param seen - Internal set to track circular references
  * @returns The redacted data
  */
-declare function redactSensitiveData(input: unknown, seen?: WeakSet<object>): unknown;
-
-export { redactSensitiveData };
+export declare function redactSensitiveData(input: unknown, seen?: WeakSet<object>): unknown;
+//# sourceMappingURL=redactor.d.ts.map

package/dist/utils/redactor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redactor.d.ts","sourceRoot":"","sources":["../../src/utils/redactor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAqEH;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,kBAAgB,GAAG,OAAO,CAiCjF"}

package/dist/utils/result.d.ts

@@ -1,30 +1,18 @@
-import { ZodError, z } from 'zod';
-import { Issue } from '../errors/types.js';
-import '../agent/error-codes.js';
-import '../config/error-codes.js';
-import '../context/error-codes.js';
-import '../llm/error-codes.js';
-import '../mcp/error-codes.js';
-import '../session/error-codes.js';
-import '../storage/error-codes.js';
-import '../systemPrompt/error-codes.js';
-import '../tools/error-codes.js';
-import '../preferences/error-codes.js';
-import '../agent/registry/error-codes.js';
-
+import { z, type ZodError } from 'zod';
+import type { Issue } from '../errors/types.js';
 /** Trim and require non-empty after trim */
-declare const NonEmptyTrimmed: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-declare const OptionalURL: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string | undefined, string>>;
-declare const EnvExpandedString: (env?: Record<string, string | undefined>) => z.ZodEffects<z.ZodString, string, string>;
-declare const NonEmptyEnvExpandedString: (env?: Record<string, string | undefined>) => z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-declare const RequiredEnvURL: (env?: Record<string, string | undefined>) => z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+export declare const NonEmptyTrimmed: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+export declare const OptionalURL: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string | undefined, string>>;
+export declare const EnvExpandedString: (env?: Record<string, string | undefined>) => z.ZodEffects<z.ZodString, string, string>;
+export declare const NonEmptyEnvExpandedString: (env?: Record<string, string | undefined>) => z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+export declare const RequiredEnvURL: (env?: Record<string, string | undefined>) => z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
 /**
  * A discriminated union result type that can be either successful or failed
  * Provides type safety by ensuring data is only available on success
  * @param T - The type of the data on success
  * @param C - The type of the context for issues
  */
-type Result<T, C = unknown> = {
+export type Result<T, C = unknown> = {
     ok: true;
     data: T;
     issues: Issue<C>[];
@@ -56,7 +44,7 @@ type Result<T, C = unknown> = {
  * ]);
  * ```
  */
-declare const ok: <T, C = unknown>(data: T, issues?: Issue<C>[]) => Result<T, C>;
+export declare const ok: <T, C = unknown>(data: T, issues?: Issue<C>[]) => Result<T, C>;
 /**
  * Create a failed result with blocking errors that prevent operation completion.
  *
@@ -88,7 +76,7 @@ declare const ok: <T, C = unknown>(data: T, issues?: Issue<C>[]) => Result<T, C>
  * ]);
  * ```
  */
-declare const fail: <T = never, C = unknown>(issues: Issue<C>[]) => Result<T, C>;
+export declare const fail: <T = never, C = unknown>(issues: Issue<C>[]) => Result<T, C>;
 /**
  * Check if a list of issues contains any blocking errors (non-warning severity).
  *
@@ -114,7 +102,7 @@ declare const fail: <T = never, C = unknown>(issues: Issue<C>[]) => Result<T, C>
  * }
  * ```
  */
-declare function hasErrors<C>(issues: Issue<C>[]): boolean;
+export declare function hasErrors<C>(issues: Issue<C>[]): boolean;
 /**
  * Separate issues into errors (blocking) and warnings (non-blocking) for different handling.
  *
@@ -142,7 +130,7 @@ declare function hasErrors<C>(issues: Issue<C>[]): boolean;
  * return ok(data, warnings);
  * ```
  */
-declare function splitIssues<C>(issues: Issue<C>[]): {
+export declare function splitIssues<C>(issues: Issue<C>[]): {
     errors: Issue<C>[];
     warnings: Issue<C>[];
 };
@@ -175,6 +163,5 @@ declare function splitIssues<C>(issues: Issue<C>[]): {
  * });
  * ```
  */
-declare function zodToIssues<C = unknown>(err: ZodError, severity?: 'error' | 'warning'): Issue<C>[];
-
-export { EnvExpandedString, NonEmptyEnvExpandedString, NonEmptyTrimmed, OptionalURL, RequiredEnvURL, type Result, fail, hasErrors, ok, splitIssues, zodToIssues };
+export declare function zodToIssues<C = unknown>(err: ZodError, severity?: 'error' | 'warning'): Issue<C>[];
+//# sourceMappingURL=result.d.ts.map

package/dist/utils/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/utils/result.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,KAAK,QAAQ,EAAiB,MAAM,KAAK,CAAC;AACtD,OAAO,KAAK,EAAkB,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnE,4CAA4C;AAC5C,eAAO,MAAM,eAAe,yEAG6B,CAAC;AAa1D,eAAO,MAAM,WAAW,kIAKT,CAAC;AAGhB,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,8CAUpE,CAAC;AAGP,eAAO,MAAM,yBAAyB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,4EAG5E,CAAC;AAGP,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,4EAWlE,CAAC;AAEN;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAC3B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;CAAE,GACzC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;CAAE,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,SAAQ,KAAK,CAAC,CAAC,CAAC,EAAO,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAI/E,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,OAAO,EAAE,QAAQ,KAAK,CAAC,CAAC,CAAC,EAAE,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAG3E,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,WAE9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE;;;EAKhD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,OAAO,EACnC,GAAG,EAAE,QAAQ,EACb,QAAQ,GAAE,OAAO,GAAG,SAAmB,GACxC,KAAK,CAAC,CAAC,CAAC,EAAE,CAcZ"}

package/dist/utils/safe-stringify.d.ts

@@ -2,6 +2,5 @@
  * Safe stringify that handles circular references, BigInt, and limits output size
  * Also redacts sensitive data to prevent PII leaks in error messages
  */
-declare function safeStringify(value: unknown, maxLen?: number): string;
-
-export { safeStringify };
+export declare function safeStringify(value: unknown, maxLen?: number): string;
+//# sourceMappingURL=safe-stringify.d.ts.map

package/dist/utils/safe-stringify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-stringify.d.ts","sourceRoot":"","sources":["../../src/utils/safe-stringify.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,SAAO,GAAG,MAAM,CA8BnE"}

package/dist/utils/schema-metadata.cjs

@@ -0,0 +1,235 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_metadata_exports = {};
+__export(schema_metadata_exports, {
+  extractCommonFields: () => extractCommonFields,
+  extractDiscriminatedUnionMetadata: () => extractDiscriminatedUnionMetadata,
+  extractSchemaMetadata: () => extractSchemaMetadata,
+  getFieldDefault: () => getFieldDefault,
+  isFieldRequiredInVariant: () => isFieldRequiredInVariant
+});
+module.exports = __toCommonJS(schema_metadata_exports);
+function extractDefault(def) {
+  if (def.defaultValue !== void 0) {
+    return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
+  }
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractDefault(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractDefault(def.innerType._def);
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractDefault(def.innerType._def);
+  }
+  return void 0;
+}
+function extractEnumValues(def) {
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractEnumValues(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractEnumValues(def.innerType._def);
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractEnumValues(def.innerType._def);
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    return extractEnumValues(def.schema._def);
+  }
+  if (def.typeName === "ZodEnum") {
+    return def.values;
+  }
+  if (def.typeName === "ZodLiteral") {
+    return [String(def.value)];
+  }
+  return void 0;
+}
+function extractTypeName(def) {
+  if (def.typeName === "ZodBranded" && def.type) {
+    return extractTypeName(def.type._def);
+  }
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return extractTypeName(def.innerType._def) + "?";
+  }
+  if (def.typeName === "ZodNullable" && def.innerType) {
+    return extractTypeName(def.innerType._def) + "?";
+  }
+  if (def.typeName === "ZodLiteral") {
+    return `literal(${JSON.stringify(def.value)})`;
+  }
+  if (def.typeName === "ZodEnum") {
+    return `enum(${def.values.join("|")})`;
+  }
+  if (def.typeName === "ZodArray") {
+    return `array<${extractTypeName(def.type._def)}>`;
+  }
+  if (def.typeName === "ZodRecord") {
+    return `record<${extractTypeName(def.valueType._def)}>`;
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    return extractTypeName(def.schema._def);
+  }
+  const typeMap = {
+    ZodString: "string",
+    ZodNumber: "number",
+    ZodBoolean: "boolean",
+    ZodObject: "object",
+    ZodArray: "array",
+    ZodRecord: "record",
+    ZodUnion: "union",
+    ZodDiscriminatedUnion: "discriminatedUnion"
+  };
+  return typeMap[def.typeName] || def.typeName?.replace("Zod", "").toLowerCase() || "unknown";
+}
+function isFieldRequired(def) {
+  if (def.defaultValue !== void 0) {
+    return false;
+  }
+  if (def.typeName === "ZodOptional") {
+    return false;
+  }
+  if (def.typeName === "ZodNullable") {
+    return false;
+  }
+  if (def.typeName === "ZodBranded" && def.type) {
+    return isFieldRequired(def.type._def);
+  }
+  return true;
+}
+function extractSchemaMetadata(schema) {
+  const metadata = {
+    defaults: {},
+    requiredFields: [],
+    fieldTypes: {},
+    descriptions: {},
+    enumValues: {}
+  };
+  let def = schema._def;
+  if (def.typeName === "ZodBranded" && def.type) {
+    def = def.type._def;
+  }
+  if (def.typeName !== "ZodObject") {
+    throw new Error(`Expected ZodObject, got ${def.typeName}`);
+  }
+  const shape = def.shape();
+  for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+    const fieldDef = fieldSchema._def;
+    const defaultValue = extractDefault(fieldDef);
+    if (defaultValue !== void 0) {
+      metadata.defaults[fieldName] = defaultValue;
+    }
+    if (isFieldRequired(fieldDef)) {
+      metadata.requiredFields.push(fieldName);
+    }
+    metadata.fieldTypes[fieldName] = extractTypeName(fieldDef);
+    if (fieldDef.description) {
+      metadata.descriptions[fieldName] = fieldDef.description;
+    }
+    const enumVals = extractEnumValues(fieldDef);
+    if (enumVals) {
+      metadata.enumValues[fieldName] = enumVals;
+    }
+  }
+  return metadata;
+}
+function extractDiscriminatedUnionMetadata(schema) {
+  let def = schema._def;
+  if (def.typeName === "ZodBranded" && def.type) {
+    def = def.type._def;
+  }
+  if (def.typeName === "ZodEffects" && def.schema) {
+    def = def.schema._def;
+  }
+  if (def.typeName !== "ZodDiscriminatedUnion") {
+    throw new Error(`Expected ZodDiscriminatedUnion, got ${def.typeName}`);
+  }
+  const discriminator = def.discriminator;
+  const optionsMap = def.optionsMap;
+  const metadata = {
+    discriminator,
+    options: Array.from(optionsMap.keys()),
+    schemas: {}
+  };
+  for (const [optionValue, optionSchema] of optionsMap.entries()) {
+    metadata.schemas[optionValue] = extractSchemaMetadata(optionSchema);
+  }
+  return metadata;
+}
+function extractCommonFields(metadata) {
+  const schemas = Object.values(metadata.schemas);
+  if (schemas.length === 0) {
+    return {
+      defaults: {},
+      requiredFields: [],
+      fieldTypes: {},
+      descriptions: {},
+      enumValues: {}
+    };
+  }
+  const first = schemas[0];
+  const rest = schemas.slice(1);
+  const common = {
+    defaults: { ...first.defaults },
+    requiredFields: [...first.requiredFields],
+    fieldTypes: { ...first.fieldTypes },
+    descriptions: { ...first.descriptions },
+    enumValues: { ...first.enumValues }
+  };
+  for (const schema of rest) {
+    for (const key of Object.keys(common.defaults)) {
+      if (!(key in schema.defaults) || schema.defaults[key] !== common.defaults[key]) {
+        delete common.defaults[key];
+      }
+    }
+    common.requiredFields = common.requiredFields.filter(
+      (field) => schema.requiredFields.includes(field)
+    );
+    for (const key of Object.keys(common.fieldTypes)) {
+      if (!(key in schema.fieldTypes) || schema.fieldTypes[key] !== common.fieldTypes[key]) {
+        delete common.fieldTypes[key];
+      }
+    }
+    for (const key of Object.keys(common.descriptions)) {
+      if (!(key in schema.descriptions) || schema.descriptions[key] !== common.descriptions[key]) {
+        delete common.descriptions[key];
+      }
+    }
+    for (const key of Object.keys(common.enumValues)) {
+      if (!(key in schema.enumValues) || JSON.stringify(schema.enumValues[key]) !== JSON.stringify(common.enumValues[key])) {
+        delete common.enumValues[key];
+      }
+    }
+  }
+  return common;
+}
+function getFieldDefault(metadata, discriminatorValue, fieldName) {
+  return metadata.schemas[discriminatorValue]?.defaults[fieldName];
+}
+function isFieldRequiredInVariant(metadata, discriminatorValue, fieldName) {
+  return metadata.schemas[discriminatorValue]?.requiredFields.includes(fieldName) ?? false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractCommonFields,
+  extractDiscriminatedUnionMetadata,
+  extractSchemaMetadata,
+  getFieldDefault,
+  isFieldRequiredInVariant
+});