{"version":3,"sources":["../../../src/schema/utils/defs-inferrer.ts"],"sourcesContent":["import Schema from '../schema';\r\nimport MemberDef from '../types/memberdef';\r\nimport Definitions from '../../core/definitions';\r\n\r\n/**\r\n * Result of inferring definitions from data\r\n */\r\nexport interface InferredDefs {\r\n  definitions: Definitions;\r\n  rootSchema: Schema;\r\n}\r\n\r\n/**\r\n * Represents a schema instance with its full path for conflict detection\r\n */\r\ninterface SchemaInstanceInfo {\r\n  baseName: string;      // The simple name (e.g., 'address')\r\n  fullPath: string[];    // Full path (e.g., ['employee', 'manager', 'address'])\r\n  instance: Record<string, any>;\r\n  resolvedName?: string; // Final resolved name after conflict resolution\r\n}\r\n\r\n/**\r\n * Context for tracking schema instances during deep multi-pass inference\r\n */\r\ninterface InferenceContext {\r\n  definitions: Definitions;\r\n  schemaRegistry: Map<string, Schema>;\r\n  // Collect ALL instances of each schema type globally with path info\r\n  schemaInstances: Map<string, SchemaInstanceInfo[]>;\r\n  // Track resolved names after conflict resolution\r\n  resolvedNames: Map<string, string>; // fullPath.join('.') -> resolved schema name\r\n  // Track which schemas need re-merging after collection\r\n  pendingMerge: Set<string>;\r\n  // Track which property paths have been identified as dynamic collections\r\n  // This allows us to treat single-item instances consistently\r\n  dynamicPaths: Set<string>;\r\n}\r\n\r\n/**\r\n * Detects if an object has dynamic keys (acts like a collection/map).\r\n *\r\n * Pattern: An object has dynamic keys if:\r\n * 1. All values are non-null objects (not arrays, not primitives)\r\n * 2. All objects share at least one common key\r\n *\r\n * Examples of dynamic keys:\r\n * - { \"1\": {recode:\"0\"}, \"2\": {recode:\"1\"} }  - numeric keys, share \"recode\"\r\n * - { \"QID1\": {name:\"Q1\"}, \"QID2\": {name:\"Q2\"} }  - ID keys, share \"name\"\r\n *\r\n * Examples of static keys (NOT dynamic):\r\n * - { name: \"John\", age: 30 }  - values are primitives\r\n * - { user: {name}, settings: {theme} }  - no common keys\r\n */\r\nfunction isDynamicKeyObject(obj: Record<string, any>): boolean {\r\n  const keys = Object.keys(obj);\r\n  if (keys.length < 2) return false;\r\n\r\n  const values = keys.map(k => obj[k]);\r\n\r\n  // Check 1: All values must be non-null objects (not arrays)\r\n  const allObjects = values.every(v =>\r\n    v !== null &&\r\n    typeof v === 'object' &&\r\n    !Array.isArray(v)\r\n  );\r\n\r\n  if (!allObjects) return false;\r\n\r\n  // Check 2: Find common keys across ALL objects\r\n  const allValueKeys = values.map(v => new Set(Object.keys(v)));\r\n  const firstKeys = allValueKeys[0];\r\n\r\n  // Find keys that exist in ALL objects\r\n  const commonKeys = [...firstKeys].filter(key =>\r\n    allValueKeys.every(keySet => keySet.has(key))\r\n  );\r\n\r\n  return commonKeys.length >= 1;\r\n}\r\n\r\n/**\r\n * Infers Internet Object definitions from plain JavaScript data.\r\n *\r\n * This utility analyzes the structure and types of the input data\r\n * and generates proper Definitions with:\r\n * - `$schema` for the root object (default schema)\r\n * - Named schemas like `$borrowedBy`, `$membershipType` for nested objects\r\n *\r\n * Implements Deep Multi-Pass Inference:\r\n * - Phase 1: Discovery - traverse data and identify all schema types\r\n * - Phase 2: Collection - gather ALL instances of each schema globally\r\n * - Phase 3: Conflict Resolution - resolve name conflicts for same key at different paths\r\n * - Phase 4: Merging - merge all instances to build comprehensive schemas\r\n * - Phase 5: Finalization - set up definitions with proper ordering\r\n *\r\n * @param data - The JavaScript data to infer definitions from\r\n * @returns InferredDefs containing Definitions and the root schema\r\n */\r\nexport function inferDefs(data: any): InferredDefs {\r\n  const ctx: InferenceContext = {\r\n    definitions: new Definitions(),\r\n    schemaRegistry: new Map(),\r\n    schemaInstances: new Map(),\r\n    resolvedNames: new Map(),\r\n    pendingMerge: new Set(),\r\n    dynamicPaths: new Set()\r\n  };\r\n\r\n  // Phase 0: Pre-scan to identify ALL dynamic paths across the entire data structure\r\n  // This ensures that even single-item siblings are treated as dynamic if any sibling has multiple items\r\n  preScanDynamicPaths(data, [], ctx);\r\n\r\n  // Phase 1 & 2: Discovery and Collection\r\n  // First pass to identify schema types and collect all instances with paths\r\n  collectSchemaInstances(data, '$schema', [], ctx);\r\n\r\n  // Phase 3: Resolve schema name conflicts\r\n  resolveSchemaNameConflicts(ctx);\r\n\r\n  // Phase 4: Merge all collected instances for each resolved schema\r\n  mergeAllSchemaInstances(ctx);\r\n\r\n  // Phase 5: Build the root schema with all nested schemas properly set up\r\n  const rootSchema = buildFinalSchema(data, '$schema', [], ctx);\r\n\r\n  // Set the root schema as $schema (default schema)\r\n  ctx.definitions.push('$schema', rootSchema, true, false);\r\n\r\n  return { definitions: ctx.definitions, rootSchema };\r\n}\r\n\r\n/**\r\n * Phase 0: Pre-scan to identify all dynamic paths before main collection.\r\n * This ensures that all sibling paths are treated consistently - if ANY instance\r\n * at a path has dynamic keys, ALL instances at that path will be treated as dynamic.\r\n */\r\nfunction preScanDynamicPaths(\r\n  data: any,\r\n  currentPath: string[],\r\n  ctx: InferenceContext\r\n): void {\r\n  if (data === null || data === undefined) return;\r\n\r\n  if (Array.isArray(data)) {\r\n    // Scan array items\r\n    for (const item of data) {\r\n      if (typeof item === 'object' && item !== null && !Array.isArray(item)) {\r\n        preScanDynamicPaths(item, currentPath, ctx);\r\n      }\r\n    }\r\n    return;\r\n  }\r\n\r\n  if (typeof data === 'object') {\r\n    for (const [key, value] of Object.entries(data)) {\r\n      if (value === null || value === undefined) continue;\r\n\r\n      const childPath = [...currentPath, key];\r\n      const pathKey = childPath.join('.');\r\n\r\n      if (Array.isArray(value)) {\r\n        // Scan array items\r\n        for (const item of value) {\r\n          if (typeof item === 'object' && item !== null && !Array.isArray(item)) {\r\n            preScanDynamicPaths(item, childPath, ctx);\r\n          }\r\n        }\r\n      } else if (typeof value === 'object') {\r\n        // Check if this looks like a dynamic-key object\r\n        if (isDynamicKeyObject(value)) {\r\n          ctx.dynamicPaths.add(pathKey);\r\n        }\r\n\r\n        // Recursively scan into the object's values\r\n        // For dynamic objects, we scan into each value but NOT include the dynamic key in path\r\n        // Pass childPath (the dynamic object's path) so nested properties have correct paths\r\n        if (ctx.dynamicPaths.has(pathKey) || isDynamicKeyObject(value)) {\r\n          for (const childValue of Object.values(value)) {\r\n            if (typeof childValue === 'object' && childValue !== null && !Array.isArray(childValue)) {\r\n              preScanDynamicPaths(childValue, childPath, ctx);\r\n            }\r\n          }\r\n        } else {\r\n          // Regular object - scan with full path\r\n          preScanDynamicPaths(value, childPath, ctx);\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Phase 1 & 2: Recursively traverse data to collect all schema instances with paths\r\n */\r\nfunction collectSchemaInstances(\r\n  data: any,\r\n  baseName: string,\r\n  currentPath: string[],\r\n  ctx: InferenceContext\r\n): void {\r\n  if (data === null || data === undefined) {\r\n    return;\r\n  }\r\n\r\n  if (Array.isArray(data)) {\r\n    // For arrays of objects, collect all objects as instances of the item schema\r\n    const objects = data.filter(item =>\r\n      typeof item === 'object' && item !== null && !Array.isArray(item)\r\n    );\r\n\r\n    if (objects.length > 0) {\r\n      // All objects in this array are instances of the same schema\r\n      for (const obj of objects) {\r\n        addSchemaInstance(baseName, currentPath, obj, ctx);\r\n        // Recursively collect nested instances\r\n        collectNestedInstances(obj, currentPath, ctx);\r\n      }\r\n    }\r\n    return;\r\n  }\r\n\r\n  if (typeof data === 'object') {\r\n    // Single object - add as instance and collect nested\r\n    addSchemaInstance(baseName, currentPath, data, ctx);\r\n    collectNestedInstances(data, currentPath, ctx);\r\n  }\r\n}\r\n\r\n/**\r\n * Recursively collect schema instances from nested properties\r\n */\r\nfunction collectNestedInstances(\r\n  obj: Record<string, any>,\r\n  parentPath: string[],\r\n  ctx: InferenceContext\r\n): void {\r\n  for (const [key, value] of Object.entries(obj)) {\r\n    if (value === null || value === undefined) continue;\r\n\r\n    const currentPath = [...parentPath, key];\r\n\r\n    if (Array.isArray(value)) {\r\n      // Array property - collect instances with singularized schema name\r\n      const itemBaseName = `$${singularize(key)}`;\r\n      const objects = value.filter(item =>\r\n        typeof item === 'object' && item !== null && !Array.isArray(item)\r\n      );\r\n\r\n      for (const item of objects) {\r\n        addSchemaInstance(itemBaseName, currentPath, item, ctx);\r\n        // Recursively collect from nested arrays\r\n        collectNestedInstances(item, currentPath, ctx);\r\n      }\r\n    } else if (typeof value === 'object') {\r\n      // Check if this path is marked as dynamic (from pre-scan phase)\r\n      // OR if it currently looks like a dynamic-key object\r\n      const pathKey = currentPath.join('.');\r\n      const isDynamic = ctx.dynamicPaths.has(pathKey) || isDynamicKeyObject(value);\r\n\r\n      if (isDynamic) {\r\n        // Ensure this path is marked as dynamic\r\n        ctx.dynamicPaths.add(pathKey);\r\n\r\n        // Treat as collection - all values are instances of the same schema\r\n        const itemBaseName = `$${singularize(key)}`;\r\n\r\n        for (const [dynamicKey, dynamicValue] of Object.entries(value)) {\r\n          if (dynamicValue !== null && typeof dynamicValue === 'object' && !Array.isArray(dynamicValue)) {\r\n            // Add each dynamic-keyed object as an instance of the singularized schema\r\n            addSchemaInstance(itemBaseName, currentPath, dynamicValue, ctx);\r\n            // Recursively collect from nested objects within dynamic values\r\n            // IMPORTANT: Do NOT include dynamicKey in path - this ensures all nested\r\n            // objects merge into the same schema regardless of which dynamic key they're under\r\n            collectNestedInstances(dynamicValue, currentPath, ctx);\r\n          }\r\n        }\r\n      } else {\r\n        // Regular nested object - collect with key as schema name\r\n        const nestedBaseName = `$${key}`;\r\n        addSchemaInstance(nestedBaseName, currentPath, value, ctx);\r\n        // Recursively collect from nested objects\r\n        collectNestedInstances(value, currentPath, ctx);\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Add an object as an instance of a schema type with path tracking\r\n */\r\nfunction addSchemaInstance(\r\n  baseName: string,\r\n  fullPath: string[],\r\n  obj: Record<string, any>,\r\n  ctx: InferenceContext\r\n): void {\r\n  if (!ctx.schemaInstances.has(baseName)) {\r\n    ctx.schemaInstances.set(baseName, []);\r\n  }\r\n\r\n  const instanceInfo: SchemaInstanceInfo = {\r\n    baseName,\r\n    fullPath: [...fullPath],\r\n    instance: obj\r\n  };\r\n\r\n  ctx.schemaInstances.get(baseName)!.push(instanceInfo);\r\n  ctx.pendingMerge.add(baseName);\r\n}\r\n\r\n/**\r\n * Phase 3: Resolve schema name conflicts\r\n * When the same base name appears at different paths with different structures,\r\n * instead of creating qualified names, we fall back to plain 'object' type.\r\n *\r\n * Strategy:\r\n * - Same path, varying structures → merge into ONE schema (multi-pass handles optionality)\r\n * - Different paths, same structure → share schema name\r\n * - Different paths, different structures → mark as conflicted (use plain 'object')\r\n */\r\nfunction resolveSchemaNameConflicts(ctx: InferenceContext): void {\r\n  for (const [baseName, instances] of ctx.schemaInstances) {\r\n    if (baseName === '$schema') {\r\n      // Root schema doesn't need conflict resolution\r\n      for (const info of instances) {\r\n        info.resolvedName = '$schema';\r\n        ctx.resolvedNames.set(pathKey(info.fullPath, baseName), '$schema');\r\n      }\r\n      continue;\r\n    }\r\n\r\n    // Group instances by their path signature\r\n    const pathGroups = groupInstancesByPath(instances);\r\n\r\n    if (pathGroups.size === 1) {\r\n      // All instances at same path - no conflict, use base name\r\n      // Multi-pass merging will handle structural variations (optional fields)\r\n      for (const info of instances) {\r\n        info.resolvedName = baseName;\r\n        ctx.resolvedNames.set(pathKey(info.fullPath, baseName), baseName);\r\n      }\r\n    } else {\r\n      // Multiple paths - check if structures are COMPATIBLE (have common keys)\r\n      // If they share at least one key, they can merge with optional fields\r\n      // If they share NO keys, they're truly incompatible → CONFLICT\r\n\r\n      // Collect all key sets from all instances\r\n      const allKeySets: Set<string>[] = [];\r\n      for (const info of instances) {\r\n        allKeySets.push(new Set(Object.keys(info.instance)));\r\n      }\r\n\r\n      // Find keys that exist in ALL instances\r\n      const firstKeys = allKeySets[0];\r\n      const commonKeys = [...firstKeys].filter(key =>\r\n        allKeySets.every(keySet => keySet.has(key))\r\n      );\r\n\r\n      if (commonKeys.length > 0) {\r\n        // Compatible structures - share at least one key\r\n        // Multi-pass merging will handle variations (optional fields)\r\n        for (const info of instances) {\r\n          info.resolvedName = baseName;\r\n          ctx.resolvedNames.set(pathKey(info.fullPath, baseName), baseName);\r\n        }\r\n      } else {\r\n        // No common keys at all → truly incompatible structures → CONFLICT\r\n        // These will fall back to plain 'object' type without schemaRef\r\n        for (const info of instances) {\r\n          info.resolvedName = `${baseName}::CONFLICTED`;\r\n          ctx.resolvedNames.set(pathKey(info.fullPath, baseName), `${baseName}::CONFLICTED`);\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Group instances by their path signature\r\n */\r\nfunction groupInstancesByPath(\r\n  instances: SchemaInstanceInfo[]\r\n): Map<string, SchemaInstanceInfo[]> {\r\n  const groups = new Map<string, SchemaInstanceInfo[]>();\r\n\r\n  for (const info of instances) {\r\n    // Create a normalized path signature (remove array indices conceptually)\r\n    const pathSig = info.fullPath.join('.');\r\n\r\n    if (!groups.has(pathSig)) {\r\n      groups.set(pathSig, []);\r\n    }\r\n    groups.get(pathSig)!.push(info);\r\n  }\r\n\r\n  return groups;\r\n}\r\n\r\n/**\r\n * Get a signature representing the structure of an object (keys and their types)\r\n */\r\nfunction getStructureSignature(obj: Record<string, any>): string {\r\n  const entries = Object.entries(obj)\r\n    .map(([key, value]) => {\r\n      const type = value === null ? 'null' :\r\n                   Array.isArray(value) ? 'array' :\r\n                   typeof value;\r\n      return `${key}:${type}`;\r\n    })\r\n    .sort();\r\n  return entries.join(',');\r\n}\r\n\r\n/**\r\n * Resolve conflicting names by generating qualified names from path\r\n */\r\nfunction resolveConflictingNames(\r\n  baseName: string,\r\n  pathGroups: Map<string, SchemaInstanceInfo[]>,\r\n  ctx: InferenceContext\r\n): void {\r\n  // Sort paths by length (shorter paths get simpler names)\r\n  const sortedPaths = Array.from(pathGroups.keys()).sort((a, b) => {\r\n    const aLen = a.split('.').length;\r\n    const bLen = b.split('.').length;\r\n    return aLen - bLen;\r\n  });\r\n\r\n  // First path (shortest/root level) keeps the base name\r\n  const usedNames = new Set<string>();\r\n\r\n  for (let i = 0; i < sortedPaths.length; i++) {\r\n    const pathSig = sortedPaths[i];\r\n    const groupInstances = pathGroups.get(pathSig)!;\r\n\r\n    let resolvedName: string;\r\n\r\n    if (i === 0) {\r\n      // First/shortest path keeps base name\r\n      resolvedName = baseName;\r\n    } else {\r\n      // Generate qualified name from path\r\n      resolvedName = generateQualifiedName(baseName, groupInstances[0].fullPath, usedNames);\r\n    }\r\n\r\n    usedNames.add(resolvedName);\r\n\r\n    // Apply resolved name to all instances in this path group\r\n    for (const info of groupInstances) {\r\n      info.resolvedName = resolvedName;\r\n      ctx.resolvedNames.set(pathKey(info.fullPath, baseName), resolvedName);\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Generate a qualified schema name from the path\r\n * e.g., ['employee', 'manager', 'address'] -> '$employeeManagerAddress'\r\n */\r\nfunction generateQualifiedName(\r\n  baseName: string,\r\n  fullPath: string[],\r\n  usedNames: Set<string>\r\n): string {\r\n  // Remove the $ prefix from baseName for manipulation\r\n  const simpleName = baseName.startsWith('$') ? baseName.slice(1) : baseName;\r\n\r\n  // Build qualified name from path components (excluding the last one which is the property name)\r\n  // e.g., path=['employee', 'manager', 'address'] -> 'employeeManagerAddress'\r\n  const pathParts = fullPath.slice(0, -1); // Exclude the last element (the property itself)\r\n\r\n  if (pathParts.length === 0) {\r\n    // No parent path, keep base name (shouldn't happen in conflict case)\r\n    return baseName;\r\n  }\r\n\r\n  // Build camelCase qualified name\r\n  const qualifiedParts = pathParts.map((part, index) => {\r\n    // Singularize array parent names\r\n    const singularPart = singularize(part);\r\n    if (index === 0) {\r\n      return singularPart.toLowerCase();\r\n    }\r\n    return capitalize(singularPart);\r\n  });\r\n\r\n  let qualifiedName = `$${qualifiedParts.join('')}${capitalize(simpleName)}`;\r\n\r\n  // Ensure uniqueness\r\n  let counter = 1;\r\n  let uniqueName = qualifiedName;\r\n  while (usedNames.has(uniqueName)) {\r\n    uniqueName = `${qualifiedName}${counter++}`;\r\n  }\r\n\r\n  return uniqueName;\r\n}\r\n\r\n/**\r\n * Create a unique key for path + baseName combination\r\n */\r\nfunction pathKey(fullPath: string[], baseName: string): string {\r\n  return `${fullPath.join('.')}::${baseName}`;\r\n}\r\n\r\n/**\r\n * Capitalize first letter of a string\r\n */\r\nfunction capitalize(str: string): string {\r\n  if (!str) return str;\r\n  return str.charAt(0).toUpperCase() + str.slice(1);\r\n}\r\n\r\n/**\r\n * Phase 4: Merge all collected instances for each resolved schema type\r\n */\r\nfunction mergeAllSchemaInstances(ctx: InferenceContext): void {\r\n  // Group instances by their resolved name\r\n  const resolvedGroups = new Map<string, SchemaInstanceInfo[]>();\r\n\r\n  for (const instances of ctx.schemaInstances.values()) {\r\n    for (const info of instances) {\r\n      const resolvedName = info.resolvedName || info.baseName;\r\n      if (!resolvedGroups.has(resolvedName)) {\r\n        resolvedGroups.set(resolvedName, []);\r\n      }\r\n      resolvedGroups.get(resolvedName)!.push(info);\r\n    }\r\n  }\r\n\r\n  // Build merged schema for each resolved name\r\n  for (const [resolvedName, instances] of resolvedGroups) {\r\n    if (instances.length === 0) continue;\r\n\r\n    // Skip conflicted schemas - they won't be referenced anyway\r\n    if (resolvedName.endsWith('::CONFLICTED')) {\r\n      continue;\r\n    }\r\n\r\n    // Get the representative path for this schema (from first instance)\r\n    const representativePath = instances[0].fullPath;\r\n\r\n    // Extract just the instance objects for merging\r\n    const objects = instances.map(info => info.instance);\r\n\r\n    // Build merged schema from all instances, passing the parent path context\r\n    const mergedSchema = buildMergedSchema(objects, resolvedName, representativePath, ctx);\r\n    ctx.schemaRegistry.set(resolvedName, mergedSchema);\r\n\r\n    // Don't add $schema to definitions yet (handled separately)\r\n    if (resolvedName !== '$schema') {\r\n      ctx.definitions.push(resolvedName, mergedSchema, true, false);\r\n    }\r\n  }\r\n\r\n  ctx.pendingMerge.clear();\r\n}\r\n\r\n/**\r\n * Build a merged schema from multiple object instances using multi-pass rules\r\n */\r\nfunction buildMergedSchema(\r\n  objects: Record<string, any>[],\r\n  schemaName: string,\r\n  parentPath: string[],\r\n  ctx: InferenceContext\r\n): Schema {\r\n  const memberDefs: Map<string, MemberDef> = new Map();\r\n  const memberOrder: string[] = [];\r\n  const seenInIteration: Map<string, number> = new Map();\r\n\r\n  for (let i = 0; i < objects.length; i++) {\r\n    const obj = objects[i];\r\n    const keysInThisObject = new Set(Object.keys(obj));\r\n\r\n    // Process each key in current object\r\n    for (const [key, value] of Object.entries(obj)) {\r\n      if (!memberDefs.has(key)) {\r\n        // First time seeing this key\r\n        // Pass the full path (parentPath + key) for proper schema ref resolution\r\n        const memberDef = inferMemberDefSimple(value, key, [...parentPath, key], ctx);\r\n\r\n        // Rule 2 & 3: New key in later iteration → optional\r\n        if (i > 0) {\r\n          memberDef.optional = true;\r\n        }\r\n\r\n        // Rule 1 & 3: Null value → nullable\r\n        if (value === null) {\r\n          memberDef.null = true;\r\n          memberDef.type = 'any';\r\n        }\r\n\r\n        memberDefs.set(key, memberDef);\r\n        memberOrder.push(key);\r\n        seenInIteration.set(key, i);\r\n      } else {\r\n        // Key already exists - merge/update\r\n        const existingDef = memberDefs.get(key)!;\r\n        mergeIntoMemberDef(existingDef, value, key, [...parentPath, key], ctx);\r\n      }\r\n    }\r\n\r\n    // Rule 4: Mark keys missing in this object as optional\r\n    for (const [key, def] of memberDefs) {\r\n      if (!keysInThisObject.has(key) && seenInIteration.get(key)! < i) {\r\n        def.optional = true;\r\n      }\r\n    }\r\n  }\r\n\r\n  const builder = Schema.create(schemaName);\r\n  for (const key of memberOrder) {\r\n    builder.addMember(key, memberDefs.get(key)!);\r\n  }\r\n\r\n  return builder.build();\r\n}\r\n\r\n/**\r\n * Merge a new value into an existing MemberDef (Rules 5 & 6)\r\n */\r\nfunction mergeIntoMemberDef(\r\n  existingDef: MemberDef,\r\n  value: any,\r\n  key: string,\r\n  fullPath: string[],\r\n  ctx: InferenceContext\r\n): void {\r\n  // Rule 6: Null in later iteration → add nullable\r\n  if (value === null) {\r\n    existingDef.null = true;\r\n    return;\r\n  }\r\n\r\n  if (value === undefined) {\r\n    existingDef.optional = true;\r\n    return;\r\n  }\r\n\r\n  const newDef = inferMemberDefSimple(value, key, fullPath, ctx);\r\n\r\n  // Rule 5: Type mismatch → any\r\n  if (existingDef.type !== newDef.type && existingDef.type !== 'any') {\r\n    // Real type mismatch (not just null handling)\r\n    existingDef.type = 'any';\r\n    // Clear schemaRef when becoming 'any'\r\n    delete existingDef.schemaRef;\r\n  }\r\n\r\n  // Preserve schemaRef if both are objects with same schema\r\n  if (existingDef.type === 'object' && newDef.type === 'object') {\r\n    if (newDef.schemaRef && !existingDef.schemaRef) {\r\n      existingDef.schemaRef = newDef.schemaRef;\r\n    }\r\n  }\r\n\r\n  // Preserve schemaRef for arrays\r\n  if (existingDef.type === 'array' && newDef.type === 'array') {\r\n    if (newDef.schemaRef && !existingDef.schemaRef) {\r\n      existingDef.schemaRef = newDef.schemaRef;\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Simple MemberDef inference for merge phase (uses resolved schema names based on path)\r\n * This is used during schema merging where we need basic type information\r\n * and the schema names are resolved based on the path context.\r\n */\r\nfunction inferMemberDefSimple(\r\n  value: any,\r\n  path: string,\r\n  fullPath: string[],\r\n  ctx: InferenceContext\r\n): MemberDef {\r\n  if (value === null) {\r\n    return { type: 'any', path, null: true, optional: true };\r\n  }\r\n\r\n  if (value === undefined) {\r\n    return { type: 'any', path, optional: true };\r\n  }\r\n\r\n  const jsType = typeof value;\r\n\r\n  switch (jsType) {\r\n    case 'string':\r\n      return { type: 'string', path };\r\n\r\n    case 'number':\r\n      return { type: 'number', path };\r\n\r\n    case 'bigint':\r\n      return { type: 'number', path };\r\n\r\n    case 'boolean':\r\n      return { type: 'bool', path };\r\n\r\n    case 'object':\r\n      if (Array.isArray(value)) {\r\n        return inferArrayMemberDefSimple(value, path, fullPath, ctx);\r\n      }\r\n      // Check if this is a dynamic key object (collection-like)\r\n      // Also check dynamicPaths for single-item objects that were identified as dynamic\r\n      // because a sibling has multiple items\r\n      const fullPathKey = fullPath.join('.');\r\n      if (isDynamicKeyObject(value) || ctx.dynamicPaths.has(fullPathKey)) {\r\n        // Dynamic-keyed objects (maps) should NOT have a schemaRef\r\n        // The schemaRef would describe the VALUE type, not the container itself\r\n        // When stringifying, the container should be treated as a plain object\r\n        // and each value will be validated/stringified according to the item schema\r\n        return { type: 'object', path };\r\n      }\r\n      // Regular nested object - look up the resolved name based on the full path\r\n      const baseName = `$${path}`;\r\n      const resolvedName = ctx.resolvedNames.get(pathKey(fullPath, baseName)) || baseName;\r\n      // If conflicted, fall back to plain object without schemaRef\r\n      if (resolvedName.endsWith('::CONFLICTED')) {\r\n        return { type: 'object', path };\r\n      }\r\n      return { type: 'object', path, schemaRef: resolvedName };\r\n\r\n    default:\r\n      return { type: 'any', path };\r\n  }\r\n}\r\n\r\n/**\r\n * Simple array MemberDef inference for merge phase\r\n */\r\nfunction inferArrayMemberDefSimple(\r\n  arr: any[],\r\n  path: string,\r\n  fullPath: string[],\r\n  ctx: InferenceContext\r\n): MemberDef {\r\n  if (arr.length === 0) {\r\n    return { type: 'array', path };\r\n  }\r\n\r\n  // Check if array contains objects\r\n  const hasObjects = arr.some(item =>\r\n    typeof item === 'object' && item !== null && !Array.isArray(item)\r\n  );\r\n\r\n  if (hasObjects) {\r\n    const baseName = `$${singularize(path)}`;\r\n    const resolvedName = ctx.resolvedNames.get(pathKey(fullPath, baseName)) || baseName;\r\n    // If conflicted, fall back to plain array without schemaRef\r\n    if (resolvedName.endsWith('::CONFLICTED')) {\r\n      return { type: 'array', path };\r\n    }\r\n    return { type: 'array', path, schemaRef: resolvedName };\r\n  }\r\n\r\n  // Check if array has mixed primitive types\r\n  const types = new Set(arr.map(item => typeof item));\r\n  if (types.size > 1 || arr.some(item => item === null)) {\r\n    return { type: 'array', path };\r\n  }\r\n\r\n  // For arrays of same-type primitives\r\n  return { type: 'array', path };\r\n}\r\n\r\n/**\r\n * Phase 5: Build the final schema structure using pre-merged schemas\r\n */\r\nfunction buildFinalSchema(\r\n  data: any,\r\n  schemaName: string,\r\n  currentPath: string[],\r\n  ctx: InferenceContext\r\n): Schema {\r\n  // Use the pre-merged schema if available\r\n  if (ctx.schemaRegistry.has(schemaName)) {\r\n    return ctx.schemaRegistry.get(schemaName)!;\r\n  }\r\n\r\n  // Fallback for edge cases\r\n  if (data === null || data === undefined) {\r\n    const builder = Schema.create(schemaName);\r\n    builder.addMember('value', { type: 'any', path: 'value', optional: true });\r\n    return builder.build();\r\n  }\r\n\r\n  if (Array.isArray(data)) {\r\n    const objects = data.filter(item =>\r\n      typeof item === 'object' && item !== null && !Array.isArray(item)\r\n    );\r\n    if (objects.length > 0 && ctx.schemaRegistry.has(schemaName)) {\r\n      return ctx.schemaRegistry.get(schemaName)!;\r\n    }\r\n  }\r\n\r\n  if (typeof data === 'object') {\r\n    if (ctx.schemaRegistry.has(schemaName)) {\r\n      return ctx.schemaRegistry.get(schemaName)!;\r\n    }\r\n  }\r\n\r\n  // For primitives at root (unlikely case)\r\n  const builder = Schema.create(schemaName);\r\n  builder.addMember('value', inferMemberDef(data, 'value', currentPath, ctx));\r\n  return builder.build();\r\n}\r\n\r\n/**\r\n * Infers a MemberDef from a JavaScript value\r\n */\r\nfunction inferMemberDef(\r\n  value: any,\r\n  path: string,\r\n  currentPath: string[],\r\n  ctx: InferenceContext\r\n): MemberDef {\r\n  if (value === null) {\r\n    return { type: 'any', path, null: true, optional: true };\r\n  }\r\n\r\n  if (value === undefined) {\r\n    return { type: 'any', path, optional: true };\r\n  }\r\n\r\n  const jsType = typeof value;\r\n\r\n  switch (jsType) {\r\n    case 'string':\r\n      return { type: 'string', path };\r\n\r\n    case 'number':\r\n      return { type: 'number', path };\r\n\r\n    case 'bigint':\r\n      return { type: 'number', path };\r\n\r\n    case 'boolean':\r\n      return { type: 'bool', path };\r\n\r\n    case 'object':\r\n      if (Array.isArray(value)) {\r\n        return inferArrayMemberDef(value, path, currentPath, ctx);\r\n      }\r\n      // Check if this is a dynamic key object (collection-like)\r\n      // Also check dynamicPaths for single-item objects that were identified as dynamic\r\n      // because a sibling has multiple items\r\n      // Note: currentPath already includes 'path' at the end (passed from caller)\r\n      const fullPathKey = currentPath.join('.');\r\n      if (isDynamicKeyObject(value) || ctx.dynamicPaths.has(fullPathKey)) {\r\n        // Dynamic-keyed objects (maps) should NOT have a schemaRef\r\n        // The schemaRef would describe the VALUE type, not the container itself\r\n        return { type: 'object', path };\r\n      }\r\n      // Regular nested object - reference the resolved schema name\r\n      const baseName = `$${path}`;\r\n      const resolvedName = ctx.resolvedNames.get(pathKey(currentPath, baseName)) || baseName;\r\n      return { type: 'object', path, schemaRef: resolvedName };\r\n\r\n    default:\r\n      return { type: 'any', path };\r\n  }\r\n}\r\n\r\n/**\r\n * Infers a MemberDef for an array value\r\n */\r\nfunction inferArrayMemberDef(\r\n  arr: any[],\r\n  path: string,\r\n  currentPath: string[],\r\n  ctx: InferenceContext\r\n): MemberDef {\r\n  if (arr.length === 0) {\r\n    return { type: 'array', path };\r\n  }\r\n\r\n  // Check if array contains objects\r\n  const hasObjects = arr.some(item =>\r\n    typeof item === 'object' && item !== null && !Array.isArray(item)\r\n  );\r\n\r\n  if (hasObjects) {\r\n    const baseName = `$${singularize(path)}`;\r\n    const fullPath = [...currentPath, path];\r\n    const resolvedName = ctx.resolvedNames.get(pathKey(fullPath, baseName)) || baseName;\r\n    return { type: 'array', path, schemaRef: resolvedName };\r\n  }\r\n\r\n  // Check if array has mixed primitive types\r\n  const types = new Set(arr.map(item => typeof item));\r\n  if (types.size > 1 || arr.some(item => item === null)) {\r\n    return { type: 'array', path };\r\n  }\r\n\r\n  // For arrays of same-type primitives\r\n  return { type: 'array', path };\r\n}\r\n\r\n/**\r\n * Simple singularization for common cases\r\n * books -> book, subscribers -> subscriber, categories -> category\r\n */\r\nfunction singularize(word: string): string {\r\n  // Handle common irregular plurals\r\n  const irregulars: Record<string, string> = {\r\n    'children': 'child',\r\n    'people': 'person',\r\n    'men': 'man',\r\n    'women': 'woman',\r\n    'mice': 'mouse',\r\n    'geese': 'goose',\r\n    'teeth': 'tooth',\r\n    'feet': 'foot',\r\n    'data': 'datum',\r\n    'criteria': 'criterion',\r\n    'analyses': 'analysis',\r\n    'indices': 'index'\r\n  };\r\n\r\n  const lower = word.toLowerCase();\r\n  if (irregulars[lower]) {\r\n    // Preserve original case of first letter\r\n    const singular = irregulars[lower];\r\n    return word[0] === word[0].toUpperCase()\r\n      ? singular.charAt(0).toUpperCase() + singular.slice(1)\r\n      : singular;\r\n  }\r\n\r\n  // Regular patterns\r\n  if (word.endsWith('ies') && word.length > 3) {\r\n    return word.slice(0, -3) + 'y';\r\n  }\r\n  if (word.endsWith('ves')) {\r\n    return word.slice(0, -3) + 'f';\r\n  }\r\n  if (word.endsWith('es') && (\r\n    word.endsWith('sses') ||\r\n    word.endsWith('xes') ||\r\n    word.endsWith('zes') ||\r\n    word.endsWith('ches') ||\r\n    word.endsWith('shes')\r\n  )) {\r\n    return word.slice(0, -2);\r\n  }\r\n  if (word.endsWith('s') && !word.endsWith('ss') && word.length > 1) {\r\n    return word.slice(0, -1);\r\n  }\r\n\r\n  return word;\r\n}\r\n\r\nexport default inferDefs;\r\n"],"mappings":"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","names":["Definitions","pathKey","Schema","builder"]}