axiom 0.33.0 → 0.34.1

package/dist/{chunk-MSHFK4M4.js → chunk-AAEGYMAU.js}

@@ -73,7 +73,7 @@ import { trace } from "@opentelemetry/api";
 // package.json
 var package_default = {
   name: "axiom",
-  version: "0.33.0",
+  version: "0.34.1",
   type: "module",
   author: "Axiom, Inc.",
   contributors: [
@@ -223,8 +223,8 @@ function initAxiomAI(config) {
 function getGlobalTracer() {
   const scope = globalThis[AXIOM_AI_SCOPE_KEY];
   if (!scope) {
-    const DEBUG = process.env.AXIOM_DEBUG === "true";
-    if (!DEBUG) {
+    const isDebug = process.env.AXIOM_DEBUG === "true";
+    if (!isDebug) {
       console.warn(
         "[AxiomAI] AXIOM_AI_SCOPE_KEY is undefined. This probably means that initAxiomAI() was never called. Make sure to call initAxiomAI({ tracer }) in your instrumentation setup."
       );
@@ -727,8 +727,8 @@ function isNoOpTracerProvider() {
 function getTracer() {
   const tracer = getGlobalTracer();
   if (isNoOpTracerProvider()) {
-    const DEBUG = process.env.AXIOM_DEBUG === "true";
-    if (!DEBUG) {
+    const isDebug = process.env.AXIOM_DEBUG === "true";
+    if (!isDebug) {
       console.warn(
         "[AxiomAI] No TracerProvider registered - spans will be no-op. Make sure to call initAxiomAI() after your OpenTelemetry SDK has started (sdk.start())."
       );
@@ -1039,8 +1039,8 @@ function withSpan(meta, fn, opts) {
       const provider = trace3.getTracerProvider();
       const providerIsNoOp = provider.constructor.name === "NoopTracerProvider";
       if (providerIsNoOp) {
-        const DEBUG = process.env.AXIOM_DEBUG === "true";
-        if (!DEBUG) {
+        const isDebug = process.env.AXIOM_DEBUG === "true";
+        if (!isDebug) {
           console.warn(
             "[AxiomAI] No TracerProvider registered - spans are no-op. Make sure to call initAxiomAI() after your OpenTelemetry SDK has started."
           );
@@ -2435,6 +2435,113 @@ function generateExampleForIssue(issue, path) {
 // src/util/dot-path.ts
 init_esm_shims();
 import { z } from "zod";
+
+// src/util/zod-internals.ts
+init_esm_shims();
+function isZodV4Schema(schema) {
+  if (!schema || typeof schema !== "object") return false;
+  const s = schema;
+  return "_zod" in s;
+}
+function assertZodV4(schema, context4) {
+  if (!isZodV4Schema(schema)) {
+    throw new Error(
+      `[AxiomAI] Zod v4 schemas are required (detected in ${context4}). Found unsupported Zod version.`
+    );
+  }
+}
+function getDef(schema) {
+  if (!schema || typeof schema !== "object") return void 0;
+  const s = schema;
+  if (s._zod && typeof s._zod === "object") {
+    const zod = s._zod;
+    if (zod.def && typeof zod.def === "object") {
+      return zod.def;
+    }
+  }
+  return void 0;
+}
+function getDefRawType(def) {
+  if (!def) return void 0;
+  const raw = def.type;
+  if (raw == null) return void 0;
+  return typeof raw === "string" ? raw : String(raw);
+}
+var KNOWN_KINDS = /* @__PURE__ */ new Set([
+  "object",
+  "optional",
+  "default",
+  "nullable",
+  "readonly",
+  "prefault",
+  "nonoptional",
+  "catch",
+  "array",
+  "record",
+  "union",
+  "discriminatedunion"
+]);
+function getKind(schemaOrDef) {
+  const def = schemaOrDef && typeof schemaOrDef === "object" && "type" in schemaOrDef ? schemaOrDef : getDef(schemaOrDef);
+  const raw = getDefRawType(def);
+  if (!raw) return void 0;
+  const normalized = raw.toLowerCase();
+  return KNOWN_KINDS.has(normalized) ? normalized : "other";
+}
+function isObjectSchema(schema) {
+  if (!schema || typeof schema !== "object") return false;
+  if ("shape" in schema && typeof schema.shape === "object") {
+    return true;
+  }
+  return getKind(schema) === "object";
+}
+function getInnerType(schema) {
+  const def = getDef(schema);
+  return def?.innerType;
+}
+function getArrayElement(schema) {
+  const def = getDef(schema);
+  return def?.element;
+}
+function getShape(schema) {
+  if (!schema || typeof schema !== "object") return void 0;
+  const s = schema;
+  if (s.shape && typeof s.shape === "object") {
+    return s.shape;
+  }
+  return void 0;
+}
+function getDefaultValue(schema) {
+  const def = getDef(schema);
+  return def?.defaultValue;
+}
+var TRANSPARENT_WRAPPERS = [
+  "optional",
+  "nullable",
+  "default",
+  "readonly",
+  "prefault",
+  "nonoptional",
+  "catch"
+  // transparent for schema structure, but alters error behavior
+];
+function unwrapTransparent(schema) {
+  let current = schema;
+  for (let i = 0; i < 10; i++) {
+    const kind = getKind(current);
+    if (!kind) break;
+    if (TRANSPARENT_WRAPPERS.includes(kind)) {
+      const inner = getInnerType(current);
+      if (!inner) break;
+      current = inner;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+
+// src/util/dot-path.ts
 function parsePath(path) {
   return path.split(".");
 }
@@ -2473,16 +2580,14 @@ function isValidPath(schema, segments) {
   let currentSchema = schema;
   for (let i = 0; i < segments.length; i++) {
     const segment = segments[i];
-    if (!currentSchema.shape || !(segment in currentSchema.shape)) {
+    const shape = getShape(currentSchema);
+    if (!shape || !(segment in shape)) {
       return false;
     }
     if (i < segments.length - 1) {
-      const nextSchema = currentSchema.shape[segment];
-      let unwrappedSchema = nextSchema;
-      while (unwrappedSchema?._def?.innerType || unwrappedSchema?._def?.schema) {
-        unwrappedSchema = unwrappedSchema._def.innerType || unwrappedSchema._def.schema;
-      }
-      if (!unwrappedSchema || unwrappedSchema._def?.type !== "object") {
+      const nextSchema = shape[segment];
+      const unwrappedSchema = unwrapTransparent(nextSchema);
+      if (!isObjectSchema(unwrappedSchema)) {
         return false;
       }
       currentSchema = unwrappedSchema;
@@ -2504,24 +2609,30 @@ function findSchemaAtPath(rootSchema, segments) {
   if (!rootSchema || segments.length === 0) return void 0;
   let current = rootSchema;
   if (segments.length > 0) {
-    if (!current.shape || !(segments[0] in current.shape)) {
+    const rootShape = getShape(current);
+    if (!rootShape || !(segments[0] in rootShape)) {
       return void 0;
     }
-    current = current.shape[segments[0]];
+    current = rootShape[segments[0]];
     for (let i = 1; i < segments.length; i++) {
       const segment = segments[i];
-      if (!current || !current._def) {
+      const def = getDef(current);
+      if (!def) {
         return void 0;
       }
-      if (current._def.type === "object" && current.shape) {
-        const nextSchema = current.shape[segment];
-        if (!nextSchema) {
-          return void 0;
-        }
-        current = nextSchema;
-      } else {
+      current = unwrapTransparent(current);
+      if (!isObjectSchema(current)) {
         return void 0;
       }
+      const shape = getShape(current);
+      if (!shape) {
+        return void 0;
+      }
+      const nextSchema = shape[segment];
+      if (!nextSchema) {
+        return void 0;
+      }
+      current = nextSchema;
     }
     return current;
   }
@@ -2542,8 +2653,62 @@ function buildSchemaForPath(rootSchema, segments) {
   return currentSchema;
 }
 
+// src/util/deep-partial-schema.ts
+init_esm_shims();
+import { z as z2 } from "zod";
+function makeDeepPartial(schema) {
+  const shape = schema.shape;
+  const newShape = {};
+  for (const [key, value] of Object.entries(shape)) {
+    newShape[key] = makeDeepPartialField(value);
+  }
+  return z2.object(newShape);
+}
+function makeDeepPartialField(fieldSchema) {
+  const kind = getKind(fieldSchema);
+  if (isObjectSchema(fieldSchema)) {
+    const partialObject = makeDeepPartial(fieldSchema);
+    return partialObject.optional();
+  }
+  if (kind === "optional") {
+    const inner = getInnerType(fieldSchema);
+    if (inner && isObjectSchema(inner)) {
+      const partialInner = makeDeepPartial(inner);
+      return partialInner.optional();
+    }
+    return fieldSchema;
+  }
+  if (kind === "nullable") {
+    const inner = getInnerType(fieldSchema);
+    if (inner && isObjectSchema(inner)) {
+      const partialInner = makeDeepPartial(inner);
+      return partialInner.nullable().optional();
+    }
+    return fieldSchema.optional();
+  }
+  if (kind === "default") {
+    const inner = getInnerType(fieldSchema);
+    const defaultValue = getDefaultValue(fieldSchema);
+    if (inner && isObjectSchema(inner)) {
+      const partialInner = makeDeepPartial(inner);
+      return partialInner.default(defaultValue);
+    }
+    return fieldSchema.optional();
+  }
+  if (kind === "array") {
+    const element = getArrayElement(fieldSchema);
+    if (element && isObjectSchema(element)) {
+      const partialElement = makeDeepPartial(element);
+      return z2.array(partialElement).optional();
+    }
+    return fieldSchema.optional();
+  }
+  return fieldSchema.optional();
+}
+
 // src/validate-flags.ts
 function validateCliFlags(flagSchema) {
+  assertZodV4(flagSchema, "flagSchema");
   const globalOverrides = getGlobalFlagOverrides();
   if (Object.keys(globalOverrides).length === 0) {
     return;
@@ -2561,7 +2726,8 @@ function validateFlags(flagSchema, globalOverrides) {
     }
   }
   const nestedObject = dotNotationToNested(globalOverrides);
-  const result = flagSchema.strict().partial().safeParse(nestedObject);
+  const deepPartialSchema = makeDeepPartial(flagSchema);
+  const result = deepPartialSchema.safeParse(nestedObject);
   if (!result.success) {
     console.error("\u274C Invalid CLI flags:");
     console.error(formatZodErrors(result.error));
@@ -2698,29 +2864,30 @@ function isPickedFlag(flagPath, pickedFlags) {
 }
 function assertNoUnions(schema, path = "schema") {
   if (!schema) return;
-  const def = schema._zod?.def || schema._def;
-  if (!def) return;
-  const { type: typeName, innerType } = def;
-  if (typeName === "default" || typeName === "optional" || typeName === "nullable") {
+  const kind = getKind(schema);
+  if (!kind) return;
+  if (kind === "default" || kind === "optional" || kind === "nullable") {
+    const innerType = getInnerType(schema);
     return assertNoUnions(innerType, path);
   }
-  if (typeName === "union" || typeName === "discriminatedUnion") {
+  if (kind === "union" || kind === "discriminatedunion") {
     throw new Error(`[AxiomAI] Union types are not supported in flag schemas (found at "${path}")`);
   }
-  if (typeName === "object") {
-    const shape = def.shape || schema.shape;
+  if (kind === "object") {
+    const shape = getShape(schema);
     if (shape) {
       for (const [k, v] of Object.entries(shape)) {
         assertNoUnions(v, `${path}.${k}`);
       }
     }
-  } else if (typeName === "array") {
-    const arrayType = def.type || def.innerType || schema._def && schema._def.type;
-    if (arrayType) {
-      assertNoUnions(arrayType, `${path}[]`);
+  } else if (kind === "array") {
+    const innerType = getInnerType(schema);
+    if (innerType) {
+      assertNoUnions(innerType, `${path}[]`);
     }
-  } else if (typeName === "record") {
-    const valueType = def.valueType || schema._def && schema._def.valueType;
+  } else if (kind === "record") {
+    const def = getDef(schema);
+    const valueType = def?.valueType;
     if (valueType) {
       assertNoUnions(valueType, `${path}{}`);
     }
@@ -2730,27 +2897,28 @@ function ensureAllDefaults(schema, path = "") {
   const missingDefaults = [];
   function checkDefaults(current, currentPath) {
     if (!current) return;
-    const def = current.def || current._def;
-    if (!def) return;
-    const { type: typeName, innerType, defaultValue } = def;
-    const hasDefault = defaultValue !== void 0;
-    if (typeName === "default") {
+    const kind = getKind(current);
+    if (!kind) return;
+    const def = getDef(current);
+    const hasDefault = def?.defaultValue !== void 0;
+    if (kind === "default") {
       return;
     }
-    if (typeName === "optional" || typeName === "nullable") {
+    if (kind === "optional" || kind === "nullable") {
+      const innerType = getInnerType(current);
       return checkDefaults(innerType, currentPath);
     }
-    if (typeName === "record") {
+    if (kind === "record") {
       throw new Error(
         `[AxiomAI] ZodRecord is not supported in flag schemas (found at "${currentPath || "root"}")
 All flag fields must have known keys and defaults. Consider using z.object() instead.`
       );
     }
-    if (typeName === "object") {
+    if (kind === "object") {
       if (hasDefault) {
         return;
       }
-      const shape = def.shape || current.shape;
+      const shape = getShape(current);
       if (shape) {
         for (const [k, v] of Object.entries(shape)) {
           const nextPath = currentPath ? `${currentPath}.${k}` : k;
@@ -2759,7 +2927,7 @@ All flag fields must have known keys and defaults. Consider using z.object() ins
       }
       return;
     }
-    if (typeName === "array") {
+    if (kind === "array") {
       if (!hasDefault) {
         missingDefaults.push(currentPath || "root");
       }
@@ -2782,6 +2950,12 @@ Add .default(value) to these fields or to their parent objects.`
 function createAppScope(config) {
   const flagSchemaConfig = config?.flagSchema;
   const factSchemaConfig = config?.factSchema;
+  if (flagSchemaConfig) {
+    assertZodV4(flagSchemaConfig, "flagSchema");
+  }
+  if (factSchemaConfig) {
+    assertZodV4(factSchemaConfig, "factSchema");
+  }
   if (flagSchemaConfig) {
     assertNoUnions(flagSchemaConfig, "flagSchema");
   }
@@ -2791,51 +2965,24 @@ function createAppScope(config) {
   if (flagSchemaConfig) {
     validateCliFlags(flagSchemaConfig);
   }
-  function findSchemaAtPath2(segments) {
-    if (!flagSchemaConfig || segments.length === 0) return void 0;
-    let current = flagSchemaConfig;
-    if (segments.length > 0) {
-      if (!current.shape || !(segments[0] in current.shape)) {
-        return void 0;
-      }
-      current = current.shape[segments[0]];
-      for (let i = 1; i < segments.length; i++) {
-        const segment = segments[i];
-        if (!current || !current._def) {
-          return void 0;
-        }
-        if (current._def.type === "object" && current.shape) {
-          const nextSchema = current.shape[segment];
-          if (!nextSchema) {
-            return void 0;
-          }
-          current = nextSchema;
-        } else {
-          return void 0;
-        }
-      }
-      return current;
-    }
-    return current;
-  }
   function isNamespaceAccess(segments) {
     if (!flagSchemaConfig || segments.length === 0) return false;
     if (segments.length === 1) {
       return flagSchemaConfig.shape ? segments[0] in flagSchemaConfig.shape : false;
     }
-    const schema = findSchemaAtPath2(segments);
-    return Boolean(schema?._def?.type === "object");
+    const schema = findSchemaAtPath(flagSchemaConfig, segments);
+    return isObjectSchema(schema);
   }
   function buildObjectWithDefaults(schema) {
     if (!schema) return void 0;
-    const def = schema._zod?.def || schema._def;
-    if (!def) return void 0;
+    const kind = getKind(schema);
+    if (!kind) return void 0;
     const directDefault = extractDefault(schema);
     if (directDefault !== void 0) {
       return directDefault;
     }
-    if (def.type === "object") {
-      const shape = def.shape || schema.shape;
+    if (kind === "object") {
+      const shape = getShape(schema);
       if (shape) {
         const result = {};
         for (const [key, fieldSchema] of Object.entries(shape)) {
@@ -2848,18 +2995,17 @@ function createAppScope(config) {
     return void 0;
   }
   function extractDefault(schema) {
-    if (!schema || !schema._def) return void 0;
+    if (!schema) return void 0;
     let current = schema;
-    while (current) {
-      const def = current._zod?.def || current._def;
+    for (let i = 0; i < 10; i++) {
+      const def = getDef(current);
       if (!def) break;
       if (def.defaultValue !== void 0) {
         return typeof def.defaultValue === "function" ? def.defaultValue() : def.defaultValue;
       }
-      if (def.innerType) {
-        current = def.innerType;
-      } else if (def.schema) {
-        current = def.schema;
+      const inner = getInnerType(current);
+      if (inner) {
+        current = inner;
       } else {
         break;
       }
@@ -2869,7 +3015,7 @@ function createAppScope(config) {
   function validateFinalFlagValue(dotPath, value) {
     if (!flagSchemaConfig) return { ok: true, parsed: value };
     const segments = parsePath(dotPath);
-    const fieldSchema = findSchemaAtPath2(segments);
+    const fieldSchema = findSchemaAtPath(flagSchemaConfig, segments);
     if (fieldSchema) {
       const direct = fieldSchema.safeParse(value);
       if (direct.success) return { ok: true, parsed: direct.data };
@@ -2887,6 +3033,13 @@ function createAppScope(config) {
     }
     return { ok: true, parsed: value };
   }
+  function hasUndefinedLeaves(obj) {
+    if (obj === void 0) return true;
+    if (obj === null || typeof obj !== "object") return false;
+    return Object.values(obj).some(
+      (v) => typeof v === "object" && v !== null ? hasUndefinedLeaves(v) : v === void 0
+    );
+  }
   function flag(path) {
     const segments = parsePath(path);
     const ctx = getEvalContext();
@@ -2912,9 +3065,9 @@ function createAppScope(config) {
         console.error(`[AxiomAI] Invalid flag: "${path}"`);
         return void 0;
       }
-      const schemaForPath = findSchemaAtPath2(segments);
+      const schemaForPath = findSchemaAtPath(flagSchemaConfig, segments);
       if (!schemaForPath) {
-        const namespaceSchema = findSchemaAtPath2([segments[0]]);
+        const namespaceSchema = findSchemaAtPath(flagSchemaConfig, [segments[0]]);
         if (namespaceSchema) {
           const namespaceObject = buildObjectWithDefaults(namespaceSchema);
           if (namespaceObject && typeof namespaceObject === "object") {
@@ -2927,6 +3080,18 @@ function createAppScope(config) {
         }
       } else if (isNamespaceAccess(segments)) {
         finalValue = buildObjectWithDefaults(schemaForPath);
+        if (finalValue === void 0 || hasUndefinedLeaves(finalValue)) {
+          const nsSchema = findSchemaAtPath(flagSchemaConfig, [segments[0]]);
+          if (nsSchema) {
+            const nsObj = buildObjectWithDefaults(nsSchema);
+            if (nsObj && typeof nsObj === "object") {
+              const extracted = getValueAtPath(nsObj, segments.slice(1));
+              if (extracted !== void 0) {
+                finalValue = extracted;
+              }
+            }
+          }
+        }
         if (finalValue === void 0) {
           console.error(`[AxiomAI] Invalid flag: "${path}"`);
           return void 0;
@@ -2934,7 +3099,7 @@ function createAppScope(config) {
       } else {
         finalValue = extractDefault(schemaForPath);
         if (finalValue === void 0) {
-          const nsSchema = findSchemaAtPath2([segments[0]]);
+          const nsSchema = findSchemaAtPath(flagSchemaConfig, [segments[0]]);
           if (nsSchema) {
             const nsObj = buildObjectWithDefaults(nsSchema);
             if (nsObj && typeof nsObj === "object") {
@@ -3054,10 +3219,12 @@ export {
   getGlobalFlagOverrides,
   formatZodErrors,
   generateFlagExamples,
+  assertZodV4,
   parsePath,
   dotNotationToNested,
   flattenObject,
   isValidPath,
+  makeDeepPartial,
   Attr,
   createStartActiveSpan,
   RedactionPolicy,
@@ -3084,4 +3251,4 @@ export {
   withEvalContext,
   getConfigScope
 };
-//# sourceMappingURL=chunk-MSHFK4M4.js.map
+//# sourceMappingURL=chunk-AAEGYMAU.js.map