typebars 1.0.22 → 1.0.23

package/dist/cjs/analyzer.js

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get analyze(){return analyze},get analyzeFromAst(){return analyzeFromAst},get inferBlockType(){return inferBlockType}});const _dispatchts=require("./dispatch.js");const _errors=require("./errors.js");const _maphelpersts=require("./helpers/map-helpers.js");const _parser=require("./parser.js");const _schemaresolver=require("./schema-resolver.js");const _utils=require("./utils.js");function coerceTextValue(text,targetType){switch(targetType){case"number":case"integer":{if(text==="")return undefined;const num=Number(text);if(Number.isNaN(num))return undefined;if(targetType==="integer"&&!Number.isInteger(num))return undefined;return num}case"boolean":{const lower=text.toLowerCase();if(lower==="true")return true;if(lower==="false")return false;return undefined}case"null":return null;default:return text}}function analyze(template,inputSchema={},options){return(0,_dispatchts.dispatchAnalyze)(template,options,(tpl,coerceSchema)=>{const ast=(0,_parser.parse)(tpl);return analyzeFromAst(ast,tpl,inputSchema,{identifierSchemas:options?.identifierSchemas,coerceSchema})},(child,childOptions)=>analyze(child,inputSchema,childOptions))}function analyzeFromAst(ast,template,inputSchema={},options){const ctx={root:inputSchema,current:inputSchema,diagnostics:[],template,identifierSchemas:options?.identifierSchemas,helpers:options?.helpers,coerceSchema:options?.coerceSchema};const conditionalLocations=(0,_schemaresolver.findConditionalSchemaLocations)(inputSchema);for(const loc of conditionalLocations){addDiagnostic(ctx,"UNSUPPORTED_SCHEMA","error",`Unsupported JSON Schema feature: "${loc.keyword}" at "${loc.schemaPath}". `+"Conditional schemas (if/then/else) cannot be resolved during static analysis "+"because they depend on runtime data. Consider using oneOf/anyOf combinators instead.",undefined,{path:loc.schemaPath})}if(options?.identifierSchemas){for(const[id,idSchema]of Object.entries(options.identifierSchemas)){const idLocations=(0,_schemaresolver.findConditionalSchemaLocations)(idSchema,`/identifierSchemas/${id}`);for(const loc of idLocations){addDiagnostic(ctx,"UNSUPPORTED_SCHEMA","error",`Unsupported JSON Schema feature: "${loc.keyword}" at "${loc.schemaPath}". `+"Conditional schemas (if/then/else) cannot be resolved during static analysis "+"because they depend on runtime data. Consider using oneOf/anyOf combinators instead.",undefined,{path:loc.schemaPath})}}}if(ctx.diagnostics.length>0){return{valid:false,diagnostics:ctx.diagnostics,outputSchema:{}}}const outputSchema=inferProgramType(ast,ctx);const hasErrors=ctx.diagnostics.some(d=>d.severity==="error");return{valid:!hasErrors,diagnostics:ctx.diagnostics,outputSchema:(0,_schemaresolver.simplifySchema)(outputSchema)}}function processStatement(stmt,ctx){switch(stmt.type){case"ContentStatement":case"CommentStatement":return undefined;case"MustacheStatement":return processMustache(stmt,ctx);case"BlockStatement":return inferBlockType(stmt,ctx);default:addDiagnostic(ctx,"UNANALYZABLE","warning",`Unsupported AST node type: "${stmt.type}"`,stmt);return undefined}}function processMustache(stmt,ctx){if(stmt.path.type==="SubExpression"){addDiagnostic(ctx,"UNANALYZABLE","warning","Sub-expressions are not statically analyzable",stmt);return{}}if(stmt.params.length>0||stmt.hash){const helperName=getExpressionName(stmt.path);if(helperName===_maphelpersts.MapHelpers.MAP_HELPER_NAME){return processMapHelper(stmt,ctx)}const helper=ctx.helpers?.get(helperName);if(helper){const helperParams=helper.params;if(helperParams){const requiredCount=helperParams.filter(p=>!p.optional).length;if(stmt.params.length<requiredCount){addDiagnostic(ctx,"MISSING_ARGUMENT","error",`Helper "${helperName}" expects at least ${requiredCount} argument(s), but got ${stmt.params.length}`,stmt,{helperName,expected:`${requiredCount} argument(s)`,actual:`${stmt.params.length} argument(s)`})}}for(let i=0;i<stmt.params.length;i++){const resolvedSchema=resolveExpressionWithDiagnostics(stmt.params[i],ctx,stmt);const helperParam=helperParams?.[i];if(resolvedSchema&&helperParam?.type){const expectedType=helperParam.type;if(!isParamTypeCompatible(resolvedSchema,expectedType)){const paramName=helperParam.name;addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "${paramName}" expects ${schemaTypeLabel(expectedType)}, but got ${schemaTypeLabel(resolvedSchema)}`,stmt,{helperName,expected:schemaTypeLabel(expectedType),actual:schemaTypeLabel(resolvedSchema)})}}}return helper.returnType??{type:"string"}}addDiagnostic(ctx,"UNKNOWN_HELPER","warning",`Unknown inline helper "${helperName}" — cannot analyze statically`,stmt,{helperName});return{type:"string"}}return resolveExpressionWithDiagnostics(stmt.path,ctx,stmt)??{}}function processMapHelper(stmt,ctx){const helperName=_maphelpersts.MapHelpers.MAP_HELPER_NAME;if(stmt.params.length<2){addDiagnostic(ctx,"MISSING_ARGUMENT","error",`Helper "${helperName}" expects at least 2 argument(s), but got ${stmt.params.length}`,stmt,{helperName,expected:"2 argument(s)",actual:`${stmt.params.length} argument(s)`});return{type:"array"}}const collectionExpr=stmt.params[0];const collectionSchema=resolveExpressionWithDiagnostics(collectionExpr,ctx,stmt);if(!collectionSchema){return{type:"array"}}const itemSchema=(0,_schemaresolver.resolveArrayItems)(collectionSchema,ctx.root);if(!itemSchema){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "collection" expects an array, but got ${schemaTypeLabel(collectionSchema)}`,stmt,{helperName,expected:"array",actual:schemaTypeLabel(collectionSchema)});return{type:"array"}}let effectiveItemSchema=itemSchema;const itemType=effectiveItemSchema.type;if(itemType==="array"||Array.isArray(itemType)&&itemType.includes("array")){const innerItems=(0,_schemaresolver.resolveArrayItems)(effectiveItemSchema,ctx.root);if(innerItems){effectiveItemSchema=innerItems;addDiagnostic(ctx,"MAP_IMPLICIT_FLATTEN","warning",`The "${helperName}" helper will automatically flatten the input array one level before mapping. `+`The item type "${Array.isArray(itemType)?itemType.join(" | "):itemType}" was unwrapped to its inner items schema.`,stmt,{helperName,expected:"object",actual:schemaTypeLabel(effectiveItemSchema)})}}const effectiveItemType=effectiveItemSchema.type;const isObject=effectiveItemType==="object"||Array.isArray(effectiveItemType)&&effectiveItemType.includes("object")||!effectiveItemType&&effectiveItemSchema.properties!==undefined;if(!isObject&&effectiveItemType!==undefined){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" expects an array of objects, but the array items have type "${schemaTypeLabel(effectiveItemSchema)}"`,stmt,{helperName,expected:"object",actual:schemaTypeLabel(effectiveItemSchema)});return{type:"array"}}const propertyExpr=stmt.params[1];let propertyName;if(propertyExpr.type==="PathExpression"){const bare=propertyExpr.original;addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "property" must be a quoted string. `+`Use {{ ${helperName} … "${bare}" }} instead of {{ ${helperName} … ${bare} }}`,stmt,{helperName,expected:'StringLiteral (e.g. "property")',actual:`PathExpression (${bare})`});return{type:"array"}}if(propertyExpr.type==="StringLiteral"){propertyName=propertyExpr.value}if(!propertyName){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "property" expects a quoted string literal, but got ${propertyExpr.type}`,stmt,{helperName,expected:'StringLiteral (e.g. "property")',actual:propertyExpr.type});return{type:"array"}}const propertySchema=(0,_schemaresolver.resolveSchemaPath)(effectiveItemSchema,[propertyName]);if(!propertySchema){const availableProperties=(0,_utils.getSchemaPropertyNames)(effectiveItemSchema);addDiagnostic(ctx,"UNKNOWN_PROPERTY","error",(0,_errors.createPropertyNotFoundMessage)(propertyName,availableProperties),stmt,{path:propertyName,availableProperties});return{type:"array"}}return{type:"array",items:propertySchema}}function isParamTypeCompatible(resolved,expected){if(!expected.type||!resolved.type)return true;const expectedTypes=Array.isArray(expected.type)?expected.type:[expected.type];const resolvedTypes=Array.isArray(resolved.type)?resolved.type:[resolved.type];return resolvedTypes.some(rt=>expectedTypes.some(et=>rt===et||et==="number"&&rt==="integer"||et==="integer"&&rt==="number"))}function inferProgramType(program,ctx){const effective=(0,_parser.getEffectiveBody)(program);if(effective.length===0){return{type:"string"}}const singleExpr=(0,_parser.getEffectivelySingleExpression)(program);if(singleExpr){return processMustache(singleExpr,ctx)}const singleBlock=(0,_parser.getEffectivelySingleBlock)(program);if(singleBlock){return inferBlockType(singleBlock,ctx)}const allContent=effective.every(s=>s.type==="ContentStatement");if(allContent){const text=effective.map(s=>s.value).join("").trim();if(text==="")return{type:"string"};const coercedType=ctx.coerceSchema?.type;if(typeof coercedType==="string"&&(coercedType==="string"||coercedType==="number"||coercedType==="integer"||coercedType==="boolean"||coercedType==="null")){const coercedValue=coerceTextValue(text,coercedType);return{type:coercedType,const:coercedValue}}const literalType=(0,_parser.detectLiteralType)(text);if(literalType)return{type:literalType}}const allBlocks=effective.every(s=>s.type==="BlockStatement");if(allBlocks){const types=[];for(const stmt of effective){const t=inferBlockType(stmt,ctx);if(t)types.push(t)}if(types.length===1)return types[0];if(types.length>1)return(0,_schemaresolver.simplifySchema)({oneOf:types});return{type:"string"}}for(const stmt of program.body){processStatement(stmt,ctx)}return{type:"string"}}function inferBlockType(stmt,ctx){const helperName=getBlockHelperName(stmt);switch(helperName){case"if":case"unless":{const arg=getBlockArgument(stmt);if(arg){resolveExpressionWithDiagnostics(arg,ctx,stmt)}else{addDiagnostic(ctx,"MISSING_ARGUMENT","error",(0,_errors.createMissingArgumentMessage)(helperName),stmt,{helperName})}const thenType=inferProgramType(stmt.program,ctx);if(stmt.inverse){const elseType=inferProgramType(stmt.inverse,ctx);if((0,_utils.deepEqual)(thenType,elseType))return thenType;return(0,_schemaresolver.simplifySchema)({oneOf:[thenType,elseType]})}return thenType}case"each":{const arg=getBlockArgument(stmt);if(!arg){addDiagnostic(ctx,"MISSING_ARGUMENT","error",(0,_errors.createMissingArgumentMessage)("each"),stmt,{helperName:"each"});const saved=ctx.current;ctx.current={};inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return{type:"string"}}const collectionSchema=resolveExpressionWithDiagnostics(arg,ctx,stmt);if(!collectionSchema){const saved=ctx.current;ctx.current={};inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return{type:"string"}}const itemSchema=(0,_schemaresolver.resolveArrayItems)(collectionSchema,ctx.root);if(!itemSchema){addDiagnostic(ctx,"TYPE_MISMATCH","error",(0,_errors.createTypeMismatchMessage)("each","an array",schemaTypeLabel(collectionSchema)),stmt,{helperName:"each",expected:"array",actual:schemaTypeLabel(collectionSchema)});const saved=ctx.current;ctx.current={};inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return{type:"string"}}const saved=ctx.current;ctx.current=itemSchema;inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return{type:"string"}}case"with":{const arg=getBlockArgument(stmt);if(!arg){addDiagnostic(ctx,"MISSING_ARGUMENT","error",(0,_errors.createMissingArgumentMessage)("with"),stmt,{helperName:"with"});const saved=ctx.current;ctx.current={};const result=inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return result}const innerSchema=resolveExpressionWithDiagnostics(arg,ctx,stmt);const saved=ctx.current;ctx.current=innerSchema??{};const result=inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return result}default:{const helper=ctx.helpers?.get(helperName);if(helper){for(const param of stmt.params){resolveExpressionWithDiagnostics(param,ctx,stmt)}inferProgramType(stmt.program,ctx);if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return helper.returnType??{type:"string"}}addDiagnostic(ctx,"UNKNOWN_HELPER","warning",(0,_errors.createUnknownHelperMessage)(helperName),stmt,{helperName});inferProgramType(stmt.program,ctx);if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return{type:"string"}}}}function resolveExpressionWithDiagnostics(expr,ctx,parentNode){if((0,_parser.isThisExpression)(expr)){return ctx.current}if(expr.type==="SubExpression"){return resolveSubExpression(expr,ctx,parentNode)}const segments=(0,_parser.extractPathSegments)(expr);if(segments.length===0){if(expr.type==="StringLiteral")return{type:"string"};if(expr.type==="NumberLiteral")return{type:"number"};if(expr.type==="BooleanLiteral")return{type:"boolean"};if(expr.type==="NullLiteral")return{type:"null"};if(expr.type==="UndefinedLiteral")return{};addDiagnostic(ctx,"UNANALYZABLE","warning",(0,_errors.createUnanalyzableMessage)(expr.type),parentNode??expr);return undefined}const{cleanSegments,identifier}=(0,_parser.extractExpressionIdentifier)(segments);if((0,_parser.isRootPathTraversal)(cleanSegments)){const fullPath=cleanSegments.join(".");addDiagnostic(ctx,"ROOT_PATH_TRAVERSAL","error",(0,_errors.createRootPathTraversalMessage)(fullPath),parentNode??expr,{path:fullPath});return undefined}if((0,_parser.isRootSegments)(cleanSegments)){if(identifier!==null){return resolveRootWithIdentifier(identifier,ctx,parentNode??expr)}return ctx.current}if(identifier!==null){return resolveWithIdentifier(cleanSegments,identifier,ctx,parentNode??expr)}const resolved=(0,_schemaresolver.resolveSchemaPath)(ctx.current,cleanSegments);if(resolved===undefined){const fullPath=cleanSegments.join(".");const availableProperties=(0,_utils.getSchemaPropertyNames)(ctx.current);addDiagnostic(ctx,"UNKNOWN_PROPERTY","error",(0,_errors.createPropertyNotFoundMessage)(fullPath,availableProperties),parentNode??expr,{path:fullPath,availableProperties});return undefined}return resolved}function resolveRootWithIdentifier(identifier,ctx,node){if(!ctx.identifierSchemas){addDiagnostic(ctx,"MISSING_IDENTIFIER_SCHEMAS","error",`Property "$root:${identifier}" uses an identifier but no identifier schemas were provided`,node,{path:`$root:${identifier}`,identifier});return undefined}const idSchema=ctx.identifierSchemas[identifier];if(!idSchema){addDiagnostic(ctx,"UNKNOWN_IDENTIFIER","error",`Property "$root:${identifier}" references identifier ${identifier} but no schema exists for this identifier`,node,{path:`$root:${identifier}`,identifier});return undefined}return idSchema}function resolveWithIdentifier(cleanSegments,identifier,ctx,node){const fullPath=cleanSegments.join(".");if(!ctx.identifierSchemas){addDiagnostic(ctx,"MISSING_IDENTIFIER_SCHEMAS","error",`Property "${fullPath}:${identifier}" uses an identifier but no identifier schemas were provided`,node,{path:`${fullPath}:${identifier}`,identifier});return undefined}const idSchema=ctx.identifierSchemas[identifier];if(!idSchema){addDiagnostic(ctx,"UNKNOWN_IDENTIFIER","error",`Property "${fullPath}:${identifier}" references identifier ${identifier} but no schema exists for this identifier`,node,{path:`${fullPath}:${identifier}`,identifier});return undefined}const resolved=(0,_schemaresolver.resolveSchemaPath)(idSchema,cleanSegments);if(resolved===undefined){const availableProperties=(0,_utils.getSchemaPropertyNames)(idSchema);addDiagnostic(ctx,"IDENTIFIER_PROPERTY_NOT_FOUND","error",`Property "${fullPath}" does not exist in the schema for identifier ${identifier}`,node,{path:fullPath,identifier,availableProperties});return undefined}return resolved}function resolveSubExpression(expr,ctx,parentNode){const helperName=getExpressionName(expr.path);if(helperName===_maphelpersts.MapHelpers.MAP_HELPER_NAME){return processMapSubExpression(expr,ctx,parentNode)}const helper=ctx.helpers?.get(helperName);if(!helper){addDiagnostic(ctx,"UNKNOWN_HELPER","warning",`Unknown sub-expression helper "${helperName}" — cannot analyze statically`,parentNode??expr,{helperName});return{type:"string"}}const helperParams=helper.params;if(helperParams){const requiredCount=helperParams.filter(p=>!p.optional).length;if(expr.params.length<requiredCount){addDiagnostic(ctx,"MISSING_ARGUMENT","error",`Helper "${helperName}" expects at least ${requiredCount} argument(s), but got ${expr.params.length}`,parentNode??expr,{helperName,expected:`${requiredCount} argument(s)`,actual:`${expr.params.length} argument(s)`})}}for(let i=0;i<expr.params.length;i++){const resolvedSchema=resolveExpressionWithDiagnostics(expr.params[i],ctx,parentNode??expr);const helperParam=helperParams?.[i];if(resolvedSchema&&helperParam?.type){const expectedType=helperParam.type;if(!isParamTypeCompatible(resolvedSchema,expectedType)){const paramName=helperParam.name;addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "${paramName}" expects ${schemaTypeLabel(expectedType)}, but got ${schemaTypeLabel(resolvedSchema)}`,parentNode??expr,{helperName,expected:schemaTypeLabel(expectedType),actual:schemaTypeLabel(resolvedSchema)})}}}return helper.returnType??{type:"string"}}function processMapSubExpression(expr,ctx,parentNode){const helperName=_maphelpersts.MapHelpers.MAP_HELPER_NAME;const node=parentNode??expr;if(expr.params.length<2){addDiagnostic(ctx,"MISSING_ARGUMENT","error",`Helper "${helperName}" expects at least 2 argument(s), but got ${expr.params.length}`,node,{helperName,expected:"2 argument(s)",actual:`${expr.params.length} argument(s)`});return{type:"array"}}const collectionExpr=expr.params[0];const collectionSchema=resolveExpressionWithDiagnostics(collectionExpr,ctx,node);if(!collectionSchema){return{type:"array"}}const itemSchema=(0,_schemaresolver.resolveArrayItems)(collectionSchema,ctx.root);if(!itemSchema){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "collection" expects an array, but got ${schemaTypeLabel(collectionSchema)}`,node,{helperName,expected:"array",actual:schemaTypeLabel(collectionSchema)});return{type:"array"}}let effectiveItemSchema=itemSchema;const itemType=effectiveItemSchema.type;if(itemType==="array"||Array.isArray(itemType)&&itemType.includes("array")){const innerItems=(0,_schemaresolver.resolveArrayItems)(effectiveItemSchema,ctx.root);if(innerItems){effectiveItemSchema=innerItems}}const effectiveItemType=effectiveItemSchema.type;const isObject=effectiveItemType==="object"||Array.isArray(effectiveItemType)&&effectiveItemType.includes("object")||!effectiveItemType&&effectiveItemSchema.properties!==undefined;if(!isObject&&effectiveItemType!==undefined){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" expects an array of objects, but the array items have type "${schemaTypeLabel(effectiveItemSchema)}"`,node,{helperName,expected:"object",actual:schemaTypeLabel(effectiveItemSchema)});return{type:"array"}}const propertyExpr=expr.params[1];let propertyName;if(propertyExpr.type==="PathExpression"){const bare=propertyExpr.original;addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "property" must be a quoted string. `+`Use (${helperName} … "${bare}") instead of (${helperName} … ${bare})`,node,{helperName,expected:'StringLiteral (e.g. "property")',actual:`PathExpression (${bare})`});return{type:"array"}}if(propertyExpr.type==="StringLiteral"){propertyName=propertyExpr.value}if(!propertyName){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "property" expects a quoted string literal, but got ${propertyExpr.type}`,node,{helperName,expected:'StringLiteral (e.g. "property")',actual:propertyExpr.type});return{type:"array"}}const propertySchema=(0,_schemaresolver.resolveSchemaPath)(effectiveItemSchema,[propertyName]);if(!propertySchema){const availableProperties=(0,_utils.getSchemaPropertyNames)(effectiveItemSchema);addDiagnostic(ctx,"UNKNOWN_PROPERTY","error",(0,_errors.createPropertyNotFoundMessage)(propertyName,availableProperties),node,{path:propertyName,availableProperties});return{type:"array"}}return{type:"array",items:propertySchema}}function getBlockArgument(stmt){return stmt.params[0]}function getBlockHelperName(stmt){if(stmt.path.type==="PathExpression"){return stmt.path.original}return""}function getExpressionName(expr){if(expr.type==="PathExpression"){return expr.original}return""}function addDiagnostic(ctx,code,severity,message,node,details){const diagnostic={severity,code,message};if(node&&"loc"in node&&node.loc){diagnostic.loc={start:{line:node.loc.start.line,column:node.loc.start.column},end:{line:node.loc.end.line,column:node.loc.end.column}};diagnostic.source=(0,_utils.extractSourceSnippet)(ctx.template,diagnostic.loc)}if(details){diagnostic.details=details}ctx.diagnostics.push(diagnostic)}function schemaTypeLabel(schema){if(schema.type){return Array.isArray(schema.type)?schema.type.join(" | "):schema.type}if(schema.oneOf)return"oneOf(...)";if(schema.anyOf)return"anyOf(...)";if(schema.allOf)return"allOf(...)";if(schema.enum)return"enum";return"unknown"}
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get analyze(){return analyze},get analyzeFromAst(){return analyzeFromAst},get inferBlockType(){return inferBlockType}});const _dispatchts=require("./dispatch.js");const _errors=require("./errors.js");const _maphelpersts=require("./helpers/map-helpers.js");const _parser=require("./parser.js");const _schemaresolver=require("./schema-resolver.js");const _utils=require("./utils.js");function coerceTextValue(text,targetType){switch(targetType){case"number":case"integer":{if(text==="")return undefined;const num=Number(text);if(Number.isNaN(num))return undefined;if(targetType==="integer"&&!Number.isInteger(num))return undefined;return num}case"boolean":{const lower=text.toLowerCase();if(lower==="true")return true;if(lower==="false")return false;return undefined}case"null":return null;default:return text}}function analyze(template,inputSchema={},options){return(0,_dispatchts.dispatchAnalyze)(template,options,(tpl,coerceSchema)=>{const ast=(0,_parser.parse)(tpl);return analyzeFromAst(ast,tpl,inputSchema,{identifierSchemas:options?.identifierSchemas,coerceSchema})},(child,childOptions)=>analyze(child,inputSchema,childOptions))}function analyzeFromAst(ast,template,inputSchema={},options){const ctx={root:inputSchema,current:inputSchema,diagnostics:[],template,identifierSchemas:options?.identifierSchemas,helpers:options?.helpers,coerceSchema:options?.coerceSchema};const conditionalLocations=(0,_schemaresolver.findConditionalSchemaLocations)(inputSchema);for(const loc of conditionalLocations){addDiagnostic(ctx,"UNSUPPORTED_SCHEMA","error",`Unsupported JSON Schema feature: "${loc.keyword}" at "${loc.schemaPath}". `+"Conditional schemas (if/then/else) cannot be resolved during static analysis "+"because they depend on runtime data. Consider using oneOf/anyOf combinators instead.",undefined,{path:loc.schemaPath})}if(options?.identifierSchemas){for(const[id,idSchema]of Object.entries(options.identifierSchemas)){const idLocations=(0,_schemaresolver.findConditionalSchemaLocations)(idSchema,`/identifierSchemas/${id}`);for(const loc of idLocations){addDiagnostic(ctx,"UNSUPPORTED_SCHEMA","error",`Unsupported JSON Schema feature: "${loc.keyword}" at "${loc.schemaPath}". `+"Conditional schemas (if/then/else) cannot be resolved during static analysis "+"because they depend on runtime data. Consider using oneOf/anyOf combinators instead.",undefined,{path:loc.schemaPath})}}}if(ctx.diagnostics.length>0){return{valid:false,diagnostics:ctx.diagnostics,outputSchema:{}}}const outputSchema=inferProgramType(ast,ctx);const hasErrors=ctx.diagnostics.some(d=>d.severity==="error");return{valid:!hasErrors,diagnostics:ctx.diagnostics,outputSchema:(0,_schemaresolver.simplifySchema)(outputSchema)}}function processStatement(stmt,ctx){switch(stmt.type){case"ContentStatement":case"CommentStatement":return undefined;case"MustacheStatement":return processMustache(stmt,ctx);case"BlockStatement":return inferBlockType(stmt,ctx);default:addDiagnostic(ctx,"UNANALYZABLE","warning",`Unsupported AST node type: "${stmt.type}"`,stmt);return undefined}}function processMustache(stmt,ctx){if(stmt.path.type==="SubExpression"){addDiagnostic(ctx,"UNANALYZABLE","warning","Sub-expressions are not statically analyzable",stmt);return{}}if(stmt.params.length>0||stmt.hash){const helperName=getExpressionName(stmt.path);if(helperName===_maphelpersts.MapHelpers.MAP_HELPER_NAME){return processMapHelper(stmt,ctx)}const helper=ctx.helpers?.get(helperName);if(helper){const helperParams=helper.params;if(helperParams){const requiredCount=helperParams.filter(p=>!p.optional).length;if(stmt.params.length<requiredCount){addDiagnostic(ctx,"MISSING_ARGUMENT","error",`Helper "${helperName}" expects at least ${requiredCount} argument(s), but got ${stmt.params.length}`,stmt,{helperName,expected:`${requiredCount} argument(s)`,actual:`${stmt.params.length} argument(s)`})}}for(let i=0;i<stmt.params.length;i++){const resolvedSchema=resolveExpressionWithDiagnostics(stmt.params[i],ctx,stmt);const helperParam=helperParams?.[i];if(resolvedSchema&&helperParam?.type){const expectedType=helperParam.type;if(!isParamTypeCompatible(resolvedSchema,expectedType)){const paramName=helperParam.name;addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "${paramName}" expects ${schemaTypeLabel(expectedType)}, but got ${schemaTypeLabel(resolvedSchema)}`,stmt,{helperName,expected:schemaTypeLabel(expectedType),actual:schemaTypeLabel(resolvedSchema)})}}}return helper.returnType??{type:"string"}}addDiagnostic(ctx,"UNKNOWN_HELPER","warning",`Unknown inline helper "${helperName}" — cannot analyze statically`,stmt,{helperName});return{type:"string"}}return resolveExpressionWithDiagnostics(stmt.path,ctx,stmt)??{}}function processMapHelper(stmt,ctx){const helperName=_maphelpersts.MapHelpers.MAP_HELPER_NAME;if(stmt.params.length<2){addDiagnostic(ctx,"MISSING_ARGUMENT","error",`Helper "${helperName}" expects at least 2 argument(s), but got ${stmt.params.length}`,stmt,{helperName,expected:"2 argument(s)",actual:`${stmt.params.length} argument(s)`});return{type:"array"}}const collectionExpr=stmt.params[0];const collectionSchema=resolveExpressionWithDiagnostics(collectionExpr,ctx,stmt);if(!collectionSchema){return{type:"array"}}const itemSchema=(0,_schemaresolver.resolveArrayItems)(collectionSchema,ctx.root);if(!itemSchema){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "collection" expects an array, but got ${schemaTypeLabel(collectionSchema)}`,stmt,{helperName,expected:"array",actual:schemaTypeLabel(collectionSchema)});return{type:"array"}}let effectiveItemSchema=itemSchema;const itemType=effectiveItemSchema.type;if(itemType==="array"||Array.isArray(itemType)&&itemType.includes("array")){const innerItems=(0,_schemaresolver.resolveArrayItems)(effectiveItemSchema,ctx.root);if(innerItems){effectiveItemSchema=innerItems;addDiagnostic(ctx,"MAP_IMPLICIT_FLATTEN","warning",`The "${helperName}" helper will automatically flatten the input array one level before mapping. `+`The item type "${Array.isArray(itemType)?itemType.join(" | "):itemType}" was unwrapped to its inner items schema.`,stmt,{helperName,expected:"object",actual:schemaTypeLabel(effectiveItemSchema)})}}const effectiveItemType=effectiveItemSchema.type;const isObject=effectiveItemType==="object"||Array.isArray(effectiveItemType)&&effectiveItemType.includes("object")||!effectiveItemType&&effectiveItemSchema.properties!==undefined;if(!isObject&&effectiveItemType!==undefined){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" expects an array of objects, but the array items have type "${schemaTypeLabel(effectiveItemSchema)}"`,stmt,{helperName,expected:"object",actual:schemaTypeLabel(effectiveItemSchema)});return{type:"array"}}const propertyExpr=stmt.params[1];let propertyName;if(propertyExpr.type==="PathExpression"){const bare=propertyExpr.original;addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "property" must be a quoted string. `+`Use {{ ${helperName} … "${bare}" }} instead of {{ ${helperName} … ${bare} }}`,stmt,{helperName,expected:'StringLiteral (e.g. "property")',actual:`PathExpression (${bare})`});return{type:"array"}}if(propertyExpr.type==="StringLiteral"){propertyName=propertyExpr.value}if(!propertyName){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "property" expects a quoted string literal, but got ${propertyExpr.type}`,stmt,{helperName,expected:'StringLiteral (e.g. "property")',actual:propertyExpr.type});return{type:"array"}}const propertySchema=(0,_schemaresolver.resolveSchemaPath)(effectiveItemSchema,[propertyName]);if(!propertySchema){const availableProperties=(0,_utils.getSchemaPropertyNames)(effectiveItemSchema);addDiagnostic(ctx,"UNKNOWN_PROPERTY","error",(0,_errors.createPropertyNotFoundMessage)(propertyName,availableProperties),stmt,{path:propertyName,availableProperties});return{type:"array"}}return{type:"array",items:propertySchema}}function isParamTypeCompatible(resolved,expected){if(!expected.type||!resolved.type)return true;const expectedTypes=Array.isArray(expected.type)?expected.type:[expected.type];const resolvedTypes=Array.isArray(resolved.type)?resolved.type:[resolved.type];return resolvedTypes.some(rt=>expectedTypes.some(et=>rt===et||et==="number"&&rt==="integer"||et==="integer"&&rt==="number"))}function inferProgramType(program,ctx){const effective=(0,_parser.getEffectiveBody)(program);if(effective.length===0){return{type:"string"}}const singleExpr=(0,_parser.getEffectivelySingleExpression)(program);if(singleExpr){return processMustache(singleExpr,ctx)}const singleBlock=(0,_parser.getEffectivelySingleBlock)(program);if(singleBlock){return inferBlockType(singleBlock,ctx)}const allContent=effective.every(s=>s.type==="ContentStatement");if(allContent){const text=effective.map(s=>s.value).join("").trim();if(text==="")return{type:"string"};const coercedType=ctx.coerceSchema?.type;if(typeof coercedType==="string"&&(coercedType==="string"||coercedType==="number"||coercedType==="integer"||coercedType==="boolean"||coercedType==="null")){const coercedValue=coerceTextValue(text,coercedType);return{type:coercedType,const:coercedValue}}const literalType=(0,_parser.detectLiteralType)(text);if(literalType)return{type:literalType}}const allBlocks=effective.every(s=>s.type==="BlockStatement");if(allBlocks){const types=[];for(const stmt of effective){const t=inferBlockType(stmt,ctx);if(t)types.push(t)}if(types.length===1)return types[0];if(types.length>1)return(0,_schemaresolver.simplifySchema)({oneOf:types});return{type:"string"}}for(const stmt of program.body){processStatement(stmt,ctx)}return{type:"string"}}function inferBlockType(stmt,ctx){const helperName=getBlockHelperName(stmt);switch(helperName){case"if":case"unless":{const arg=getBlockArgument(stmt);if(arg){resolveExpressionWithDiagnostics(arg,ctx,stmt)}else{addDiagnostic(ctx,"MISSING_ARGUMENT","error",(0,_errors.createMissingArgumentMessage)(helperName),stmt,{helperName})}const thenType=inferProgramType(stmt.program,ctx);if(stmt.inverse){const elseType=inferProgramType(stmt.inverse,ctx);if((0,_utils.deepEqual)(thenType,elseType))return thenType;return(0,_schemaresolver.simplifySchema)({oneOf:[thenType,elseType]})}return thenType}case"each":{const arg=getBlockArgument(stmt);if(!arg){addDiagnostic(ctx,"MISSING_ARGUMENT","error",(0,_errors.createMissingArgumentMessage)("each"),stmt,{helperName:"each"});const saved=ctx.current;ctx.current={};inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return{type:"string"}}const collectionSchema=resolveExpressionWithDiagnostics(arg,ctx,stmt);if(!collectionSchema){const saved=ctx.current;ctx.current={};inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return{type:"string"}}const itemSchema=(0,_schemaresolver.resolveArrayItems)(collectionSchema,ctx.root);if(!itemSchema){addDiagnostic(ctx,"TYPE_MISMATCH","error",(0,_errors.createTypeMismatchMessage)("each","an array",schemaTypeLabel(collectionSchema)),stmt,{helperName:"each",expected:"array",actual:schemaTypeLabel(collectionSchema)});const saved=ctx.current;ctx.current={};inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return{type:"string"}}const saved=ctx.current;ctx.current=itemSchema;inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return{type:"string"}}case"with":{const arg=getBlockArgument(stmt);if(!arg){addDiagnostic(ctx,"MISSING_ARGUMENT","error",(0,_errors.createMissingArgumentMessage)("with"),stmt,{helperName:"with"});const saved=ctx.current;ctx.current={};const result=inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return result}const innerSchema=resolveExpressionWithDiagnostics(arg,ctx,stmt);const saved=ctx.current;ctx.current=innerSchema??{};const result=inferProgramType(stmt.program,ctx);ctx.current=saved;if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return result}default:{const helper=ctx.helpers?.get(helperName);if(helper){for(const param of stmt.params){resolveExpressionWithDiagnostics(param,ctx,stmt)}inferProgramType(stmt.program,ctx);if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return helper.returnType??{type:"string"}}addDiagnostic(ctx,"UNKNOWN_HELPER","warning",(0,_errors.createUnknownHelperMessage)(helperName),stmt,{helperName});inferProgramType(stmt.program,ctx);if(stmt.inverse)inferProgramType(stmt.inverse,ctx);return{type:"string"}}}}function resolveExpressionWithDiagnostics(expr,ctx,parentNode){if((0,_parser.isThisExpression)(expr)){return ctx.current}if(expr.type==="SubExpression"){return resolveSubExpression(expr,ctx,parentNode)}const segments=(0,_parser.extractPathSegments)(expr);if(segments.length===0){if(expr.type==="StringLiteral")return{type:"string"};if(expr.type==="NumberLiteral")return{type:"number"};if(expr.type==="BooleanLiteral")return{type:"boolean"};if(expr.type==="NullLiteral")return{type:"null"};if(expr.type==="UndefinedLiteral")return{};addDiagnostic(ctx,"UNANALYZABLE","warning",(0,_errors.createUnanalyzableMessage)(expr.type),parentNode??expr);return undefined}const{cleanSegments,identifier}=(0,_parser.extractExpressionIdentifier)(segments);if((0,_parser.isRootPathTraversal)(cleanSegments)){const fullPath=cleanSegments.join(".");addDiagnostic(ctx,"ROOT_PATH_TRAVERSAL","error",(0,_errors.createRootPathTraversalMessage)(fullPath),parentNode??expr,{path:fullPath});return undefined}if((0,_parser.isRootSegments)(cleanSegments)){if(identifier!==null){return resolveRootWithIdentifier(identifier,ctx,parentNode??expr)}return ctx.current}if(identifier!==null){return resolveWithIdentifier(cleanSegments,identifier,ctx,parentNode??expr)}const resolved=(0,_schemaresolver.resolveSchemaPath)(ctx.current,cleanSegments);if(resolved===undefined){const fullPath=cleanSegments.join(".");const availableProperties=(0,_utils.getSchemaPropertyNames)(ctx.current);addDiagnostic(ctx,"UNKNOWN_PROPERTY","error",(0,_errors.createPropertyNotFoundMessage)(fullPath,availableProperties),parentNode??expr,{path:fullPath,availableProperties});return undefined}return resolved}function resolveRootWithIdentifier(identifier,ctx,node){if(!ctx.identifierSchemas){addDiagnostic(ctx,"MISSING_IDENTIFIER_SCHEMAS","error",`Property "$root:${identifier}" uses an identifier but no identifier schemas were provided`,node,{path:`$root:${identifier}`,identifier});return undefined}const idSchema=ctx.identifierSchemas[identifier];if(!idSchema){addDiagnostic(ctx,"UNKNOWN_IDENTIFIER","error",`Property "$root:${identifier}" references identifier ${identifier} but no schema exists for this identifier`,node,{path:`$root:${identifier}`,identifier});return undefined}return idSchema}function resolveWithIdentifier(cleanSegments,identifier,ctx,node){const fullPath=cleanSegments.join(".");if(!ctx.identifierSchemas){addDiagnostic(ctx,"MISSING_IDENTIFIER_SCHEMAS","error",`Property "${fullPath}:${identifier}" uses an identifier but no identifier schemas were provided`,node,{path:`${fullPath}:${identifier}`,identifier});return undefined}const idSchema=ctx.identifierSchemas[identifier];if(!idSchema){addDiagnostic(ctx,"UNKNOWN_IDENTIFIER","error",`Property "${fullPath}:${identifier}" references identifier ${identifier} but no schema exists for this identifier`,node,{path:`${fullPath}:${identifier}`,identifier});return undefined}const itemSchema=(0,_schemaresolver.resolveArrayItems)(idSchema,ctx.root);if(itemSchema!==undefined){const resolved=(0,_schemaresolver.resolveSchemaPath)(itemSchema,cleanSegments);if(resolved===undefined){const availableProperties=(0,_utils.getSchemaPropertyNames)(itemSchema);addDiagnostic(ctx,"IDENTIFIER_PROPERTY_NOT_FOUND","error",`Property "${fullPath}" does not exist in the items schema for identifier ${identifier}`,node,{path:fullPath,identifier,availableProperties});return undefined}return{type:"array",items:resolved}}const resolved=(0,_schemaresolver.resolveSchemaPath)(idSchema,cleanSegments);if(resolved===undefined){const availableProperties=(0,_utils.getSchemaPropertyNames)(idSchema);addDiagnostic(ctx,"IDENTIFIER_PROPERTY_NOT_FOUND","error",`Property "${fullPath}" does not exist in the schema for identifier ${identifier}`,node,{path:fullPath,identifier,availableProperties});return undefined}return resolved}function resolveSubExpression(expr,ctx,parentNode){const helperName=getExpressionName(expr.path);if(helperName===_maphelpersts.MapHelpers.MAP_HELPER_NAME){return processMapSubExpression(expr,ctx,parentNode)}const helper=ctx.helpers?.get(helperName);if(!helper){addDiagnostic(ctx,"UNKNOWN_HELPER","warning",`Unknown sub-expression helper "${helperName}" — cannot analyze statically`,parentNode??expr,{helperName});return{type:"string"}}const helperParams=helper.params;if(helperParams){const requiredCount=helperParams.filter(p=>!p.optional).length;if(expr.params.length<requiredCount){addDiagnostic(ctx,"MISSING_ARGUMENT","error",`Helper "${helperName}" expects at least ${requiredCount} argument(s), but got ${expr.params.length}`,parentNode??expr,{helperName,expected:`${requiredCount} argument(s)`,actual:`${expr.params.length} argument(s)`})}}for(let i=0;i<expr.params.length;i++){const resolvedSchema=resolveExpressionWithDiagnostics(expr.params[i],ctx,parentNode??expr);const helperParam=helperParams?.[i];if(resolvedSchema&&helperParam?.type){const expectedType=helperParam.type;if(!isParamTypeCompatible(resolvedSchema,expectedType)){const paramName=helperParam.name;addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "${paramName}" expects ${schemaTypeLabel(expectedType)}, but got ${schemaTypeLabel(resolvedSchema)}`,parentNode??expr,{helperName,expected:schemaTypeLabel(expectedType),actual:schemaTypeLabel(resolvedSchema)})}}}return helper.returnType??{type:"string"}}function processMapSubExpression(expr,ctx,parentNode){const helperName=_maphelpersts.MapHelpers.MAP_HELPER_NAME;const node=parentNode??expr;if(expr.params.length<2){addDiagnostic(ctx,"MISSING_ARGUMENT","error",`Helper "${helperName}" expects at least 2 argument(s), but got ${expr.params.length}`,node,{helperName,expected:"2 argument(s)",actual:`${expr.params.length} argument(s)`});return{type:"array"}}const collectionExpr=expr.params[0];const collectionSchema=resolveExpressionWithDiagnostics(collectionExpr,ctx,node);if(!collectionSchema){return{type:"array"}}const itemSchema=(0,_schemaresolver.resolveArrayItems)(collectionSchema,ctx.root);if(!itemSchema){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "collection" expects an array, but got ${schemaTypeLabel(collectionSchema)}`,node,{helperName,expected:"array",actual:schemaTypeLabel(collectionSchema)});return{type:"array"}}let effectiveItemSchema=itemSchema;const itemType=effectiveItemSchema.type;if(itemType==="array"||Array.isArray(itemType)&&itemType.includes("array")){const innerItems=(0,_schemaresolver.resolveArrayItems)(effectiveItemSchema,ctx.root);if(innerItems){effectiveItemSchema=innerItems}}const effectiveItemType=effectiveItemSchema.type;const isObject=effectiveItemType==="object"||Array.isArray(effectiveItemType)&&effectiveItemType.includes("object")||!effectiveItemType&&effectiveItemSchema.properties!==undefined;if(!isObject&&effectiveItemType!==undefined){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" expects an array of objects, but the array items have type "${schemaTypeLabel(effectiveItemSchema)}"`,node,{helperName,expected:"object",actual:schemaTypeLabel(effectiveItemSchema)});return{type:"array"}}const propertyExpr=expr.params[1];let propertyName;if(propertyExpr.type==="PathExpression"){const bare=propertyExpr.original;addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "property" must be a quoted string. `+`Use (${helperName} … "${bare}") instead of (${helperName} … ${bare})`,node,{helperName,expected:'StringLiteral (e.g. "property")',actual:`PathExpression (${bare})`});return{type:"array"}}if(propertyExpr.type==="StringLiteral"){propertyName=propertyExpr.value}if(!propertyName){addDiagnostic(ctx,"TYPE_MISMATCH","error",`Helper "${helperName}" parameter "property" expects a quoted string literal, but got ${propertyExpr.type}`,node,{helperName,expected:'StringLiteral (e.g. "property")',actual:propertyExpr.type});return{type:"array"}}const propertySchema=(0,_schemaresolver.resolveSchemaPath)(effectiveItemSchema,[propertyName]);if(!propertySchema){const availableProperties=(0,_utils.getSchemaPropertyNames)(effectiveItemSchema);addDiagnostic(ctx,"UNKNOWN_PROPERTY","error",(0,_errors.createPropertyNotFoundMessage)(propertyName,availableProperties),node,{path:propertyName,availableProperties});return{type:"array"}}return{type:"array",items:propertySchema}}function getBlockArgument(stmt){return stmt.params[0]}function getBlockHelperName(stmt){if(stmt.path.type==="PathExpression"){return stmt.path.original}return""}function getExpressionName(expr){if(expr.type==="PathExpression"){return expr.original}return""}function addDiagnostic(ctx,code,severity,message,node,details){const diagnostic={severity,code,message};if(node&&"loc"in node&&node.loc){diagnostic.loc={start:{line:node.loc.start.line,column:node.loc.start.column},end:{line:node.loc.end.line,column:node.loc.end.column}};diagnostic.source=(0,_utils.extractSourceSnippet)(ctx.template,diagnostic.loc)}if(details){diagnostic.details=details}ctx.diagnostics.push(diagnostic)}function schemaTypeLabel(schema){if(schema.type){return Array.isArray(schema.type)?schema.type.join(" | "):schema.type}if(schema.oneOf)return"oneOf(...)";if(schema.anyOf)return"anyOf(...)";if(schema.allOf)return"allOf(...)";if(schema.enum)return"enum";return"unknown"}
 //# sourceMappingURL=analyzer.js.map

package/dist/cjs/analyzer.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/analyzer.ts"],"sourcesContent":["import type { JSONSchema7 } from \"json-schema\";\nimport { dispatchAnalyze } from \"./dispatch.ts\";\nimport {\n\tcreateMissingArgumentMessage,\n\tcreatePropertyNotFoundMessage,\n\tcreateRootPathTraversalMessage,\n\tcreateTypeMismatchMessage,\n\tcreateUnanalyzableMessage,\n\tcreateUnknownHelperMessage,\n} from \"./errors\";\nimport { MapHelpers } from \"./helpers/map-helpers.ts\";\nimport {\n\tdetectLiteralType,\n\textractExpressionIdentifier,\n\textractPathSegments,\n\tgetEffectiveBody,\n\tgetEffectivelySingleBlock,\n\tgetEffectivelySingleExpression,\n\tisRootPathTraversal,\n\tisRootSegments,\n\tisThisExpression,\n\tparse,\n} from \"./parser\";\nimport {\n\tfindConditionalSchemaLocations,\n\tresolveArrayItems,\n\tresolveSchemaPath,\n\tsimplifySchema,\n} from \"./schema-resolver\";\nimport type {\n\tAnalysisResult,\n\tDiagnosticCode,\n\tDiagnosticDetails,\n\tHelperDefinition,\n\tTemplateDiagnostic,\n\tTemplateInput,\n} from \"./types.ts\";\nimport {\n\tdeepEqual,\n\textractSourceSnippet,\n\tgetSchemaPropertyNames,\n} from \"./utils\";\n\n// ─── Static Analyzer ─────────────────────────────────────────────────────────\n// Static analysis of a Handlebars template against a JSON Schema v7\n// describing the available context.\n//\n// Merged architecture (v2):\n// A single AST traversal performs both **validation** and **return type\n// inference** simultaneously. This eliminates duplication between the former\n// `validate*` and `infer*` functions and improves performance by avoiding\n// a double traversal.\n//\n// Context:\n// The analysis context uses a **save/restore** pattern instead of creating\n// new objects on each recursion (`{ ...ctx, current: X }`). This reduces\n// GC pressure for deeply nested templates.\n//\n// ─── Template Identifiers ────────────────────────────────────────────────────\n// The `{{key:N}}` syntax allows referencing a variable from a specific\n// schema, identified by an integer N. The optional `identifierSchemas`\n// parameter provides a mapping `{ [id]: JSONSchema7 }`.\n//\n// Resolution rules:\n// - `{{meetingId}}`   → validated against `inputSchema` (standard behavior)\n// - `{{meetingId:1}}` → validated against `identifierSchemas[1]`\n// - `{{meetingId:1}}` without `identifierSchemas[1]` → error\n\n// ─── Internal Types ──────────────────────────────────────────────────────────\n\n/** Context passed recursively during AST traversal */\ninterface AnalysisContext {\n\t/** Root schema (for resolving $refs) */\n\troot: JSONSchema7;\n\t/** Current context schema (changes with #each, #with) — mutated via save/restore */\n\tcurrent: JSONSchema7;\n\t/** Diagnostics accumulator */\n\tdiagnostics: TemplateDiagnostic[];\n\t/** Full template source (for extracting error snippets) */\n\ttemplate: string;\n\t/** Schemas by template identifier (for the {{key:N}} syntax) */\n\tidentifierSchemas?: Record<number, JSONSchema7>;\n\t/** Registered custom helpers (for static analysis) */\n\thelpers?: Map<string, HelperDefinition>;\n\t/**\n\t * Explicit coercion schema provided by the caller.\n\t * When set, static literal values like `\"123\"` will respect the type\n\t * declared in this schema instead of being auto-detected by\n\t * `detectLiteralType`. Unlike the previous `expectedOutputType`,\n\t * this is NEVER derived from the inputSchema — it must be explicitly\n\t * provided via the `coerceSchema` option.\n\t */\n\tcoerceSchema?: JSONSchema7;\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/** Options for the standalone `analyze()` function */\nexport interface AnalyzeOptions {\n\t/** Schemas by template identifier (for the `{{key:N}}` syntax) */\n\tidentifierSchemas?: Record<number, JSONSchema7>;\n\t/**\n\t * Explicit coercion schema. When provided, static literal values\n\t * will respect the types declared in this schema instead of being\n\t * auto-detected by `detectLiteralType`.\n\t *\n\t * This schema is independent from the `inputSchema` (which describes\n\t * available variables) — it only controls the output type inference\n\t * for static content.\n\t */\n\tcoerceSchema?: JSONSchema7;\n\t/**\n\t * When `true`, properties whose values contain Handlebars expressions\n\t * (i.e. any `{{…}}` syntax) are excluded from the output schema.\n\t *\n\t * Only the properties with static values (literals, plain strings\n\t * without expressions) are retained. This is useful when you want\n\t * the output schema to describe only the known, compile-time-constant\n\t * portion of the template.\n\t *\n\t * This option only has an effect on **object** and **array** templates.\n\t * A root-level string template with expressions is analyzed normally\n\t * (there is no parent property to exclude it from).\n\t *\n\t * @default false\n\t */\n\texcludeTemplateExpression?: boolean;\n}\n\n// ─── Coerce Text Value ──────────────────────────────────────────────────────\n\n/**\n * Parses a raw text string into the appropriate JS primitive according to the\n * target JSON Schema type.  Used when `coerceSchema` overrides the default\n * `detectLiteralType` inference for static literal values.\n */\nfunction coerceTextValue(\n\ttext: string,\n\ttargetType: \"string\" | \"number\" | \"integer\" | \"boolean\" | \"null\",\n): string | number | boolean | null | undefined {\n\tswitch (targetType) {\n\t\tcase \"number\":\n\t\tcase \"integer\": {\n\t\t\tif (text === \"\") return undefined;\n\t\t\tconst num = Number(text);\n\t\t\tif (Number.isNaN(num)) return undefined;\n\t\t\tif (targetType === \"integer\" && !Number.isInteger(num)) return undefined;\n\t\t\treturn num;\n\t\t}\n\t\tcase \"boolean\": {\n\t\t\tconst lower = text.toLowerCase();\n\t\t\tif (lower === \"true\") return true;\n\t\t\tif (lower === \"false\") return false;\n\t\t\treturn undefined;\n\t\t}\n\t\tcase \"null\":\n\t\t\treturn null;\n\t\tdefault:\n\t\t\treturn text;\n\t}\n}\n\n/**\n * Statically analyzes a template against a JSON Schema v7 describing the\n * available context.\n *\n * Backward-compatible version — parses the template internally.\n * Uses `dispatchAnalyze` for the recursive array/object/literal dispatching,\n * delegating only the string (template) case to `analyzeFromAst`.\n *\n * @param template           - The template string (e.g. `\"Hello {{user.name}}\"`)\n * @param inputSchema        - JSON Schema v7 describing the available variables\n * @param options            - (optional) Analysis options (identifierSchemas, coerceSchema)\n * @returns An `AnalysisResult` containing validity, diagnostics, and the\n *          inferred output schema.\n */\nexport function analyze(\n\ttemplate: TemplateInput,\n\tinputSchema: JSONSchema7 = {},\n\toptions?: AnalyzeOptions,\n): AnalysisResult {\n\treturn dispatchAnalyze(\n\t\ttemplate,\n\t\toptions,\n\t\t// String handler — parse and analyze the AST\n\t\t(tpl, coerceSchema) => {\n\t\t\tconst ast = parse(tpl);\n\t\t\treturn analyzeFromAst(ast, tpl, inputSchema, {\n\t\t\t\tidentifierSchemas: options?.identifierSchemas,\n\t\t\t\tcoerceSchema,\n\t\t\t});\n\t\t},\n\t\t// Recursive handler — re-enter analyze() for child elements\n\t\t(child, childOptions) => analyze(child, inputSchema, childOptions),\n\t);\n}\n\n/**\n * Statically analyzes a template from an already-parsed AST.\n *\n * This is the internal function used by `Typebars.compile()` and\n * `CompiledTemplate.analyze()` to avoid costly re-parsing.\n *\n * @param ast               - The already-parsed Handlebars AST\n * @param template          - The template source (for error snippets)\n * @param inputSchema       - JSON Schema v7 describing the available variables\n * @param options           - Additional options\n * @returns An `AnalysisResult`\n */\nexport function analyzeFromAst(\n\tast: hbs.AST.Program,\n\ttemplate: string,\n\tinputSchema: JSONSchema7 = {},\n\toptions?: {\n\t\tidentifierSchemas?: Record<number, JSONSchema7>;\n\t\thelpers?: Map<string, HelperDefinition>;\n\t\t/**\n\t\t * Explicit coercion schema. When set, static literal values will\n\t\t * respect the types declared in this schema instead of auto-detecting.\n\t\t * Unlike `expectedOutputType`, this is NEVER derived from inputSchema.\n\t\t */\n\t\tcoerceSchema?: JSONSchema7;\n\t},\n): AnalysisResult {\n\t// ── Initialize the diagnostic context FIRST ────────────────────────\n\tconst ctx: AnalysisContext = {\n\t\troot: inputSchema,\n\t\tcurrent: inputSchema,\n\t\tdiagnostics: [],\n\t\ttemplate,\n\t\tidentifierSchemas: options?.identifierSchemas,\n\t\thelpers: options?.helpers,\n\t\tcoerceSchema: options?.coerceSchema,\n\t};\n\n\t// ── Detect unsupported schema features as diagnostics ──────────────\n\t// Conditional schemas (if/then/else) are non-resolvable without runtime\n\t// data. Instead of throwing, we collect structured diagnostics so the\n\t// caller receives a standard AnalysisResult.\n\tconst conditionalLocations = findConditionalSchemaLocations(inputSchema);\n\tfor (const loc of conditionalLocations) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNSUPPORTED_SCHEMA\",\n\t\t\t\"error\",\n\t\t\t`Unsupported JSON Schema feature: \"${loc.keyword}\" at \"${loc.schemaPath}\". ` +\n\t\t\t\t\"Conditional schemas (if/then/else) cannot be resolved during static analysis \" +\n\t\t\t\t\"because they depend on runtime data. Consider using oneOf/anyOf combinators instead.\",\n\t\t\tundefined,\n\t\t\t{ path: loc.schemaPath },\n\t\t);\n\t}\n\n\tif (options?.identifierSchemas) {\n\t\tfor (const [id, idSchema] of Object.entries(options.identifierSchemas)) {\n\t\t\tconst idLocations = findConditionalSchemaLocations(\n\t\t\t\tidSchema,\n\t\t\t\t`/identifierSchemas/${id}`,\n\t\t\t);\n\t\t\tfor (const loc of idLocations) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"UNSUPPORTED_SCHEMA\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\t`Unsupported JSON Schema feature: \"${loc.keyword}\" at \"${loc.schemaPath}\". ` +\n\t\t\t\t\t\t\"Conditional schemas (if/then/else) cannot be resolved during static analysis \" +\n\t\t\t\t\t\t\"because they depend on runtime data. Consider using oneOf/anyOf combinators instead.\",\n\t\t\t\t\tundefined,\n\t\t\t\t\t{ path: loc.schemaPath },\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\t// If unsupported schemas were found, return early with valid: false\n\tif (ctx.diagnostics.length > 0) {\n\t\treturn {\n\t\t\tvalid: false,\n\t\t\tdiagnostics: ctx.diagnostics,\n\t\t\toutputSchema: {},\n\t\t};\n\t}\n\n\t// Single pass: type inference + validation in one traversal.\n\tconst outputSchema = inferProgramType(ast, ctx);\n\n\tconst hasErrors = ctx.diagnostics.some((d) => d.severity === \"error\");\n\n\treturn {\n\t\tvalid: !hasErrors,\n\t\tdiagnostics: ctx.diagnostics,\n\t\toutputSchema: simplifySchema(outputSchema),\n\t};\n}\n\n// ─── Unified AST Traversal ───────────────────────────────────────────────────\n// A single set of functions handles both validation (emitting diagnostics)\n// and type inference (returning a JSONSchema7).\n//\n// Main functions:\n// - `inferProgramType`   — entry point for a Program (template body or block)\n// - `processStatement`   — dispatches a statement (validation side-effects)\n// - `processMustache`    — handles a MustacheStatement (expression or inline helper)\n// - `inferBlockType`     — handles a BlockStatement (if, each, with, custom…)\n\n/**\n * Dispatches the processing of an individual statement.\n *\n * Called by `inferProgramType` in the \"mixed template\" case to validate\n * each statement while ignoring the returned type (the result is always\n * `string` for a mixed template).\n *\n * @returns The inferred schema for this statement, or `undefined` for\n *          statements with no semantics (ContentStatement, CommentStatement).\n */\nfunction processStatement(\n\tstmt: hbs.AST.Statement,\n\tctx: AnalysisContext,\n): JSONSchema7 | undefined {\n\tswitch (stmt.type) {\n\t\tcase \"ContentStatement\":\n\t\tcase \"CommentStatement\":\n\t\t\t// Static text or comment — nothing to validate, no type to infer\n\t\t\treturn undefined;\n\n\t\tcase \"MustacheStatement\":\n\t\t\treturn processMustache(stmt as hbs.AST.MustacheStatement, ctx);\n\n\t\tcase \"BlockStatement\":\n\t\t\treturn inferBlockType(stmt as hbs.AST.BlockStatement, ctx);\n\n\t\tdefault:\n\t\t\t// Unrecognized AST node — emit a warning rather than an error\n\t\t\t// to avoid blocking on future Handlebars extensions.\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"UNANALYZABLE\",\n\t\t\t\t\"warning\",\n\t\t\t\t`Unsupported AST node type: \"${stmt.type}\"`,\n\t\t\t\tstmt,\n\t\t\t);\n\t\t\treturn undefined;\n\t}\n}\n\n/**\n * Processes a MustacheStatement `{{expression}}` or `{{helper arg}}`.\n *\n * Distinguishes two cases:\n * 1. **Simple expression** (`{{name}}`, `{{user.age}}`) — resolution in the schema\n * 2. **Inline helper** (`{{uppercase name}}`) — params > 0 or hash present\n *\n * @returns The inferred schema for this expression\n */\nfunction processMustache(\n\tstmt: hbs.AST.MustacheStatement,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\t// Sub-expressions (nested helpers) are not supported for static\n\t// analysis — emit a warning.\n\tif (stmt.path.type === \"SubExpression\") {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNANALYZABLE\",\n\t\t\t\"warning\",\n\t\t\t\"Sub-expressions are not statically analyzable\",\n\t\t\tstmt,\n\t\t);\n\t\treturn {};\n\t}\n\n\t// ── Inline helper detection ──────────────────────────────────────────────\n\t// If the MustacheStatement has parameters or a hash, it's a helper call\n\t// (e.g. `{{uppercase name}}`), not a simple expression.\n\tif (stmt.params.length > 0 || stmt.hash) {\n\t\tconst helperName = getExpressionName(stmt.path);\n\n\t\t// ── Special-case: map helper ─────────────────────────────────────\n\t\t// The `map` helper requires deep static analysis that the generic\n\t\t// helper path cannot perform: it must resolve the first argument as\n\t\t// an array-of-objects schema, then resolve the second argument (a\n\t\t// property name) within the item schema to infer the output type\n\t\t// `{ type: \"array\", items: <property schema> }`.\n\t\tif (helperName === MapHelpers.MAP_HELPER_NAME) {\n\t\t\treturn processMapHelper(stmt, ctx);\n\t\t}\n\n\t\t// Check if the helper is registered\n\t\tconst helper = ctx.helpers?.get(helperName);\n\t\tif (helper) {\n\t\t\tconst helperParams = helper.params;\n\n\t\t\t// ── Check the number of required parameters ──────────────\n\t\t\tif (helperParams) {\n\t\t\t\tconst requiredCount = helperParams.filter((p) => !p.optional).length;\n\t\t\t\tif (stmt.params.length < requiredCount) {\n\t\t\t\t\taddDiagnostic(\n\t\t\t\t\t\tctx,\n\t\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\t\"error\",\n\t\t\t\t\t\t`Helper \"${helperName}\" expects at least ${requiredCount} argument(s), but got ${stmt.params.length}`,\n\t\t\t\t\t\tstmt,\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\thelperName,\n\t\t\t\t\t\t\texpected: `${requiredCount} argument(s)`,\n\t\t\t\t\t\t\tactual: `${stmt.params.length} argument(s)`,\n\t\t\t\t\t\t},\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// ── Validate each parameter (existence + type) ───────────────\n\t\t\tfor (let i = 0; i < stmt.params.length; i++) {\n\t\t\t\tconst resolvedSchema = resolveExpressionWithDiagnostics(\n\t\t\t\t\tstmt.params[i] as hbs.AST.Expression,\n\t\t\t\t\tctx,\n\t\t\t\t\tstmt,\n\t\t\t\t);\n\n\t\t\t\t// Check type compatibility if the helper declares the\n\t\t\t\t// expected type for this parameter\n\t\t\t\tconst helperParam = helperParams?.[i];\n\t\t\t\tif (resolvedSchema && helperParam?.type) {\n\t\t\t\t\tconst expectedType = helperParam.type;\n\t\t\t\t\tif (!isParamTypeCompatible(resolvedSchema, expectedType)) {\n\t\t\t\t\t\tconst paramName = helperParam.name;\n\t\t\t\t\t\taddDiagnostic(\n\t\t\t\t\t\t\tctx,\n\t\t\t\t\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\t\t\t\t\"error\",\n\t\t\t\t\t\t\t`Helper \"${helperName}\" parameter \"${paramName}\" expects ${schemaTypeLabel(expectedType)}, but got ${schemaTypeLabel(resolvedSchema)}`,\n\t\t\t\t\t\t\tstmt,\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\thelperName,\n\t\t\t\t\t\t\t\texpected: schemaTypeLabel(expectedType),\n\t\t\t\t\t\t\t\tactual: schemaTypeLabel(resolvedSchema),\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn helper.returnType ?? { type: \"string\" };\n\t\t}\n\n\t\t// Unknown inline helper — warning\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_HELPER\",\n\t\t\t\"warning\",\n\t\t\t`Unknown inline helper \"${helperName}\" — cannot analyze statically`,\n\t\t\tstmt,\n\t\t\t{ helperName },\n\t\t);\n\t\treturn { type: \"string\" };\n\t}\n\n\t// ── Simple expression ────────────────────────────────────────────────────\n\treturn resolveExpressionWithDiagnostics(stmt.path, ctx, stmt) ?? {};\n}\n\n// ─── map helper — special-case analysis ──────────────────────────────────────\n// Validates the arguments and infers the precise return type:\n//   {{ map <arrayPath> <propertyName> }}\n//   → { type: \"array\", items: <schema of the property in the item> }\n//\n// Validation rules:\n// 1. Exactly 2 arguments are required\n// 2. The first argument must resolve to an array schema\n// 3. The array items must be an object schema\n// 4. The second argument must be a string literal (property name)\n// 5. The property must exist in the item schema\n\nfunction processMapHelper(\n\tstmt: hbs.AST.MustacheStatement,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\tconst helperName = MapHelpers.MAP_HELPER_NAME;\n\n\t// ── 1. Check argument count ──────────────────────────────────────────\n\tif (stmt.params.length < 2) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" expects at least 2 argument(s), but got ${stmt.params.length}`,\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"2 argument(s)\",\n\t\t\t\tactual: `${stmt.params.length} argument(s)`,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 2. Resolve the first argument (collection path) ──────────────────\n\tconst collectionExpr = stmt.params[0] as hbs.AST.Expression;\n\tconst collectionSchema = resolveExpressionWithDiagnostics(\n\t\tcollectionExpr,\n\t\tctx,\n\t\tstmt,\n\t);\n\n\tif (!collectionSchema) {\n\t\t// Path resolution failed — diagnostic already emitted\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 3. Validate that the collection is an array ──────────────────────\n\tconst itemSchema = resolveArrayItems(collectionSchema, ctx.root);\n\tif (!itemSchema) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"collection\" expects an array, but got ${schemaTypeLabel(collectionSchema)}`,\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"array\",\n\t\t\t\tactual: schemaTypeLabel(collectionSchema),\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 4. Validate that the items are objects ───────────────────────────\n\t// If the items are arrays (e.g. from a nested map), flatten one level\n\t// to match the runtime `flat(1)` behavior and use the inner items instead.\n\tlet effectiveItemSchema = itemSchema;\n\tconst itemType = effectiveItemSchema.type;\n\tif (\n\t\titemType === \"array\" ||\n\t\t(Array.isArray(itemType) && itemType.includes(\"array\"))\n\t) {\n\t\tconst innerItems = resolveArrayItems(effectiveItemSchema, ctx.root);\n\t\tif (innerItems) {\n\t\t\teffectiveItemSchema = innerItems;\n\t\t\t// Emit an informational warning so consumers know the flatten happened\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"MAP_IMPLICIT_FLATTEN\",\n\t\t\t\t\"warning\",\n\t\t\t\t`The \"${helperName}\" helper will automatically flatten the input array one level before mapping. ` +\n\t\t\t\t\t`The item type \"${Array.isArray(itemType) ? itemType.join(\" | \") : itemType}\" was unwrapped to its inner items schema.`,\n\t\t\t\tstmt,\n\t\t\t\t{\n\t\t\t\t\thelperName,\n\t\t\t\t\texpected: \"object\",\n\t\t\t\t\tactual: schemaTypeLabel(effectiveItemSchema),\n\t\t\t\t},\n\t\t\t);\n\t\t}\n\t}\n\n\tconst effectiveItemType = effectiveItemSchema.type;\n\tconst isObject =\n\t\teffectiveItemType === \"object\" ||\n\t\t(Array.isArray(effectiveItemType) &&\n\t\t\teffectiveItemType.includes(\"object\")) ||\n\t\t// If no type but has properties, treat as object\n\t\t(!effectiveItemType && effectiveItemSchema.properties !== undefined);\n\n\tif (!isObject && effectiveItemType !== undefined) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" expects an array of objects, but the array items have type \"${schemaTypeLabel(effectiveItemSchema)}\"`,\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"object\",\n\t\t\t\tactual: schemaTypeLabel(effectiveItemSchema),\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 5. Validate the second argument (property name) ──────────────────\n\tconst propertyExpr = stmt.params[1] as hbs.AST.Expression;\n\n\t// The property name MUST be a StringLiteral (quoted string like `\"name\"`).\n\t// A bare identifier like `name` is parsed by Handlebars as a PathExpression,\n\t// which would be resolved as a data path at runtime — yielding `undefined`\n\t// when the identifier doesn't exist in the top-level context. This is a\n\t// common mistake, so we provide a clear error message guiding the user.\n\tlet propertyName: string | undefined;\n\n\tif (propertyExpr.type === \"PathExpression\") {\n\t\tconst bare = (propertyExpr as hbs.AST.PathExpression).original;\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"property\" must be a quoted string. ` +\n\t\t\t\t`Use {{ ${helperName} … \"${bare}\" }} instead of {{ ${helperName} … ${bare} }}`,\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: 'StringLiteral (e.g. \"property\")',\n\t\t\t\tactual: `PathExpression (${bare})`,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\tif (propertyExpr.type === \"StringLiteral\") {\n\t\tpropertyName = (propertyExpr as hbs.AST.StringLiteral).value;\n\t}\n\n\tif (!propertyName) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"property\" expects a quoted string literal, but got ${propertyExpr.type}`,\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: 'StringLiteral (e.g. \"property\")',\n\t\t\t\tactual: propertyExpr.type,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 6. Resolve the property within the item schema ───────────────────\n\tconst propertySchema = resolveSchemaPath(effectiveItemSchema, [propertyName]);\n\tif (!propertySchema) {\n\t\tconst availableProperties = getSchemaPropertyNames(effectiveItemSchema);\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_PROPERTY\",\n\t\t\t\"error\",\n\t\t\tcreatePropertyNotFoundMessage(propertyName, availableProperties),\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\tpath: propertyName,\n\t\t\t\tavailableProperties,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 7. Return the inferred output schema ─────────────────────────────\n\treturn { type: \"array\", items: propertySchema };\n}\n\n/**\n * Checks whether a resolved type is compatible with the type expected\n * by a helper parameter.\n *\n * Compatibility rules:\n * - If either schema has no `type`, validation is not possible → compatible\n * - `integer` is compatible with `number` (integer ⊂ number)\n * - For multiple types (e.g. `[\"string\", \"number\"]`), at least one resolved\n *   type must match one expected type\n */\nfunction isParamTypeCompatible(\n\tresolved: JSONSchema7,\n\texpected: JSONSchema7,\n): boolean {\n\t// If either has no type info, we cannot validate\n\tif (!expected.type || !resolved.type) return true;\n\n\tconst expectedTypes = Array.isArray(expected.type)\n\t\t? expected.type\n\t\t: [expected.type];\n\tconst resolvedTypes = Array.isArray(resolved.type)\n\t\t? resolved.type\n\t\t: [resolved.type];\n\n\t// At least one resolved type must be compatible with one expected type\n\treturn resolvedTypes.some((rt) =>\n\t\texpectedTypes.some(\n\t\t\t(et) =>\n\t\t\t\trt === et ||\n\t\t\t\t// integer is a subtype of number\n\t\t\t\t(et === \"number\" && rt === \"integer\") ||\n\t\t\t\t(et === \"integer\" && rt === \"number\"),\n\t\t),\n\t);\n}\n\n/**\n * Infers the output type of a `Program` (template body or block body).\n *\n * Handles 4 cases, from most specific to most general:\n *\n * 1. **Single expression** `{{expr}}` → type of the expression\n * 2. **Single block** `{{#if}}…{{/if}}` → type of the block\n * 3. **Pure text content** → literal detection (number, boolean, null)\n * 4. **Mixed template** → always `string` (concatenation)\n *\n * Validation is performed alongside inference: each expression and block\n * is validated during processing.\n */\nfunction inferProgramType(\n\tprogram: hbs.AST.Program,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\tconst effective = getEffectiveBody(program);\n\n\t// No significant statements → empty string\n\tif (effective.length === 0) {\n\t\treturn { type: \"string\" };\n\t}\n\n\t// ── Case 1: single expression {{expr}} ─────────────────────────────────\n\tconst singleExpr = getEffectivelySingleExpression(program);\n\tif (singleExpr) {\n\t\treturn processMustache(singleExpr, ctx);\n\t}\n\n\t// ── Case 2: single block {{#if}}, {{#each}}, {{#with}}, … ──────────────\n\tconst singleBlock = getEffectivelySingleBlock(program);\n\tif (singleBlock) {\n\t\treturn inferBlockType(singleBlock, ctx);\n\t}\n\n\t// ── Case 3: only ContentStatements (no expressions) ────────────────────\n\t// If the concatenated (trimmed) text is a typed literal (number, boolean,\n\t// null), we infer the corresponding type.\n\tconst allContent = effective.every((s) => s.type === \"ContentStatement\");\n\tif (allContent) {\n\t\tconst text = effective\n\t\t\t.map((s) => (s as hbs.AST.ContentStatement).value)\n\t\t\t.join(\"\")\n\t\t\t.trim();\n\n\t\tif (text === \"\") return { type: \"string\" };\n\n\t\t// If an explicit coerceSchema was provided and declares a specific\n\t\t// primitive type, respect it instead of auto-detecting. For example,\n\t\t// \"123\" with coerceSchema `{ type: \"string\" }` should stay \"string\".\n\t\t// This only applies when coerceSchema is explicitly set — the\n\t\t// inputSchema is NEVER used for coercion.\n\t\t//\n\t\t// Only the **type** is extracted from coerceSchema. Value-level\n\t\t// constraints (enum, const, format, pattern, minLength, …) are NOT\n\t\t// propagated because they describe what the *consumer* accepts, not\n\t\t// what the literal *produces*. The actual literal value is set as\n\t\t// `const` so downstream compatibility checkers can detect mismatches.\n\t\tconst coercedType = ctx.coerceSchema?.type;\n\t\tif (\n\t\t\ttypeof coercedType === \"string\" &&\n\t\t\t(coercedType === \"string\" ||\n\t\t\t\tcoercedType === \"number\" ||\n\t\t\t\tcoercedType === \"integer\" ||\n\t\t\t\tcoercedType === \"boolean\" ||\n\t\t\t\tcoercedType === \"null\")\n\t\t) {\n\t\t\tconst coercedValue = coerceTextValue(text, coercedType);\n\t\t\treturn { type: coercedType, const: coercedValue } as JSONSchema7;\n\t\t}\n\n\t\tconst literalType = detectLiteralType(text);\n\t\tif (literalType) return { type: literalType };\n\t}\n\n\t// ── Case 4: multiple blocks only (no significant text between them) ────\n\t// When the effective body consists entirely of BlockStatements, gather\n\t// each block's inferred type and combine them via oneOf. This handles\n\t// templates like:\n\t//   {{#if showName}}{{name}}{{/if}}\n\t//   {{#if showAge}}{{age}}{{/if}}\n\t// where the output could be string OR number depending on which branch\n\t// is active.\n\tconst allBlocks = effective.every((s) => s.type === \"BlockStatement\");\n\tif (allBlocks) {\n\t\tconst types: JSONSchema7[] = [];\n\t\tfor (const stmt of effective) {\n\t\t\tconst t = inferBlockType(stmt as hbs.AST.BlockStatement, ctx);\n\t\t\tif (t) types.push(t);\n\t\t}\n\t\tif (types.length === 1) return types[0] as JSONSchema7;\n\t\tif (types.length > 1) return simplifySchema({ oneOf: types });\n\t\treturn { type: \"string\" };\n\t}\n\n\t// ── Case 5: mixed template (text + expressions, blocks…) ───────────────\n\t// Traverse all statements for validation (side-effects: diagnostics).\n\t// The result is always string (concatenation).\n\tfor (const stmt of program.body) {\n\t\tprocessStatement(stmt, ctx);\n\t}\n\treturn { type: \"string\" };\n}\n\n/**\n * Infers the output type of a BlockStatement and validates its content.\n *\n * Supports built-in helpers (`if`, `unless`, `each`, `with`) and custom\n * helpers registered via `Typebars.registerHelper()`.\n *\n * Uses the **save/restore** pattern for context: instead of creating a new\n * object `{ ...ctx, current: X }` on each recursion, we save `ctx.current`,\n * mutate it, process the body, then restore. This reduces GC pressure for\n * deeply nested templates.\n */\nfunction inferBlockType(\n\tstmt: hbs.AST.BlockStatement,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\tconst helperName = getBlockHelperName(stmt);\n\n\tswitch (helperName) {\n\t\t// ── if / unless ──────────────────────────────────────────────────────\n\t\t// Validate the condition argument, then infer types from both branches.\n\t\tcase \"if\":\n\t\tcase \"unless\": {\n\t\t\tconst arg = getBlockArgument(stmt);\n\t\t\tif (arg) {\n\t\t\t\tresolveExpressionWithDiagnostics(arg, ctx, stmt);\n\t\t\t} else {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateMissingArgumentMessage(helperName),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{ helperName },\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Infer the type of the \"then\" branch\n\t\t\tconst thenType = inferProgramType(stmt.program, ctx);\n\n\t\t\tif (stmt.inverse) {\n\t\t\t\tconst elseType = inferProgramType(stmt.inverse, ctx);\n\t\t\t\t// If both branches have the same type → single type\n\t\t\t\tif (deepEqual(thenType, elseType)) return thenType;\n\t\t\t\t// Otherwise → union of both types\n\t\t\t\treturn simplifySchema({ oneOf: [thenType, elseType] });\n\t\t\t}\n\n\t\t\t// No else branch → the result is the type of the then branch\n\t\t\t// (conceptually optional, but Handlebars returns \"\" for falsy)\n\t\t\treturn thenType;\n\t\t}\n\n\t\t// ── each ─────────────────────────────────────────────────────────────\n\t\t// Resolve the collection schema, then validate the body with the item\n\t\t// schema as the new context.\n\t\tcase \"each\": {\n\t\t\tconst arg = getBlockArgument(stmt);\n\t\t\tif (!arg) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateMissingArgumentMessage(\"each\"),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{ helperName: \"each\" },\n\t\t\t\t);\n\t\t\t\t// Validate the body with an empty context (best-effort)\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn { type: \"string\" };\n\t\t\t}\n\n\t\t\tconst collectionSchema = resolveExpressionWithDiagnostics(arg, ctx, stmt);\n\t\t\tif (!collectionSchema) {\n\t\t\t\t// The path could not be resolved — diagnostic already emitted.\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn { type: \"string\" };\n\t\t\t}\n\n\t\t\t// Resolve the schema of the array elements\n\t\t\tconst itemSchema = resolveArrayItems(collectionSchema, ctx.root);\n\t\t\tif (!itemSchema) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateTypeMismatchMessage(\n\t\t\t\t\t\t\"each\",\n\t\t\t\t\t\t\"an array\",\n\t\t\t\t\t\tschemaTypeLabel(collectionSchema),\n\t\t\t\t\t),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{\n\t\t\t\t\t\thelperName: \"each\",\n\t\t\t\t\t\texpected: \"array\",\n\t\t\t\t\t\tactual: schemaTypeLabel(collectionSchema),\n\t\t\t\t\t},\n\t\t\t\t);\n\t\t\t\t// Validate the body with an empty context (best-effort)\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn { type: \"string\" };\n\t\t\t}\n\n\t\t\t// Validate the body with the item schema as the new context\n\t\t\tconst saved = ctx.current;\n\t\t\tctx.current = itemSchema;\n\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\tctx.current = saved;\n\n\t\t\t// The inverse branch ({{else}}) keeps the parent context\n\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\n\t\t\t// An each concatenates renders → always string\n\t\t\treturn { type: \"string\" };\n\t\t}\n\n\t\t// ── with ─────────────────────────────────────────────────────────────\n\t\t// Resolve the inner schema, then validate the body with it as the\n\t\t// new context.\n\t\tcase \"with\": {\n\t\t\tconst arg = getBlockArgument(stmt);\n\t\t\tif (!arg) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateMissingArgumentMessage(\"with\"),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{ helperName: \"with\" },\n\t\t\t\t);\n\t\t\t\t// Validate the body with an empty context\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tconst result = inferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn result;\n\t\t\t}\n\n\t\t\tconst innerSchema = resolveExpressionWithDiagnostics(arg, ctx, stmt);\n\n\t\t\tconst saved = ctx.current;\n\t\t\tctx.current = innerSchema ?? {};\n\t\t\tconst result = inferProgramType(stmt.program, ctx);\n\t\t\tctx.current = saved;\n\n\t\t\t// The inverse branch keeps the parent context\n\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\n\t\t\treturn result;\n\t\t}\n\n\t\t// ── Custom or unknown helper ─────────────────────────────────────────\n\t\tdefault: {\n\t\t\tconst helper = ctx.helpers?.get(helperName);\n\t\t\tif (helper) {\n\t\t\t\t// Registered custom helper — validate parameters\n\t\t\t\tfor (const param of stmt.params) {\n\t\t\t\t\tresolveExpressionWithDiagnostics(\n\t\t\t\t\t\tparam as hbs.AST.Expression,\n\t\t\t\t\t\tctx,\n\t\t\t\t\t\tstmt,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\t// Validate the body with the current context\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn helper.returnType ?? { type: \"string\" };\n\t\t\t}\n\n\t\t\t// Unknown helper — warning\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"UNKNOWN_HELPER\",\n\t\t\t\t\"warning\",\n\t\t\t\tcreateUnknownHelperMessage(helperName),\n\t\t\t\tstmt,\n\t\t\t\t{ helperName },\n\t\t\t);\n\t\t\t// Still validate the body with the current context (best-effort)\n\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\treturn { type: \"string\" };\n\t\t}\n\t}\n}\n\n// ─── Expression Resolution ───────────────────────────────────────────────────\n\n/**\n * Resolves an AST expression to a sub-schema, emitting a diagnostic\n * if the path cannot be resolved.\n *\n * Handles the `{{key:N}}` syntax:\n * - If the expression has an identifier N → resolution in `identifierSchemas[N]`\n * - If identifier N has no associated schema → error\n * - If no identifier → resolution in `ctx.current` (standard behavior)\n *\n * @returns The resolved sub-schema, or `undefined` if the path is invalid.\n */\nfunction resolveExpressionWithDiagnostics(\n\texpr: hbs.AST.Expression,\n\tctx: AnalysisContext,\n\t/** Parent AST node (for diagnostic location) */\n\tparentNode?: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\t// Handle `this` / `.` → return the current context\n\tif (isThisExpression(expr)) {\n\t\treturn ctx.current;\n\t}\n\n\t// ── SubExpression (nested helper call, e.g. `(lt account.balance 500)`) ──\n\tif (expr.type === \"SubExpression\") {\n\t\treturn resolveSubExpression(expr as hbs.AST.SubExpression, ctx, parentNode);\n\t}\n\n\tconst segments = extractPathSegments(expr);\n\tif (segments.length === 0) {\n\t\t// Expression that is not a PathExpression (e.g. literal)\n\t\tif (expr.type === \"StringLiteral\") return { type: \"string\" };\n\t\tif (expr.type === \"NumberLiteral\") return { type: \"number\" };\n\t\tif (expr.type === \"BooleanLiteral\") return { type: \"boolean\" };\n\t\tif (expr.type === \"NullLiteral\") return { type: \"null\" };\n\t\tif (expr.type === \"UndefinedLiteral\") return {};\n\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNANALYZABLE\",\n\t\t\t\"warning\",\n\t\t\tcreateUnanalyzableMessage(expr.type),\n\t\t\tparentNode ?? expr,\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// ── Identifier extraction ──────────────────────────────────────────────\n\t// Extract the `:N` suffix BEFORE checking for `$root` so that both\n\t// `{{$root}}` and `{{$root:2}}` are handled uniformly.\n\tconst { cleanSegments, identifier } = extractExpressionIdentifier(segments);\n\n\t// ── $root token ──────────────────────────────────────────────────────\n\t// Path traversal ($root.name, $root.address.city) is always forbidden,\n\t// regardless of whether an identifier is present.\n\tif (isRootPathTraversal(cleanSegments)) {\n\t\tconst fullPath = cleanSegments.join(\".\");\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"ROOT_PATH_TRAVERSAL\",\n\t\t\t\"error\",\n\t\t\tcreateRootPathTraversalMessage(fullPath),\n\t\t\tparentNode ?? expr,\n\t\t\t{ path: fullPath },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// `{{$root}}` → return the entire current context schema\n\t// `{{$root:N}}` → return the entire schema for identifier N\n\tif (isRootSegments(cleanSegments)) {\n\t\tif (identifier !== null) {\n\t\t\treturn resolveRootWithIdentifier(identifier, ctx, parentNode ?? expr);\n\t\t}\n\t\treturn ctx.current;\n\t}\n\n\tif (identifier !== null) {\n\t\t// The expression uses the {{key:N}} syntax — resolve from\n\t\t// the schema of identifier N.\n\t\treturn resolveWithIdentifier(\n\t\t\tcleanSegments,\n\t\t\tidentifier,\n\t\t\tctx,\n\t\t\tparentNode ?? expr,\n\t\t);\n\t}\n\n\t// ── Standard resolution (no identifier) ────────────────────────────────\n\tconst resolved = resolveSchemaPath(ctx.current, cleanSegments);\n\tif (resolved === undefined) {\n\t\tconst fullPath = cleanSegments.join(\".\");\n\t\tconst availableProperties = getSchemaPropertyNames(ctx.current);\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_PROPERTY\",\n\t\t\t\"error\",\n\t\t\tcreatePropertyNotFoundMessage(fullPath, availableProperties),\n\t\t\tparentNode ?? expr,\n\t\t\t{ path: fullPath, availableProperties },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\treturn resolved;\n}\n\n/**\n * Resolves `{{$root:N}}` — returns the **entire** schema for identifier N.\n *\n * This is the identifier-aware counterpart of returning `ctx.current` for\n * a plain `{{$root}}`. Instead of navigating into properties, it returns\n * the identifier's root schema directly.\n *\n * Emits an error diagnostic if:\n * - No `identifierSchemas` were provided\n * - Identifier N has no associated schema\n */\nfunction resolveRootWithIdentifier(\n\tidentifier: number,\n\tctx: AnalysisContext,\n\tnode: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\t// No identifierSchemas provided at all\n\tif (!ctx.identifierSchemas) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"MISSING_IDENTIFIER_SCHEMAS\",\n\t\t\t\"error\",\n\t\t\t`Property \"$root:${identifier}\" uses an identifier but no identifier schemas were provided`,\n\t\t\tnode,\n\t\t\t{ path: `$root:${identifier}`, identifier },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// The identifier does not exist in the provided schemas\n\tconst idSchema = ctx.identifierSchemas[identifier];\n\tif (!idSchema) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_IDENTIFIER\",\n\t\t\t\"error\",\n\t\t\t`Property \"$root:${identifier}\" references identifier ${identifier} but no schema exists for this identifier`,\n\t\t\tnode,\n\t\t\t{ path: `$root:${identifier}`, identifier },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// Return the entire schema for identifier N\n\treturn idSchema;\n}\n\n/**\n * Resolves an expression with identifier `{{key:N}}` by looking up the\n * schema associated with identifier N.\n *\n * Emits an error diagnostic if:\n * - No `identifierSchemas` were provided\n * - Identifier N has no associated schema\n * - The property does not exist in the identifier's schema\n */\nfunction resolveWithIdentifier(\n\tcleanSegments: string[],\n\tidentifier: number,\n\tctx: AnalysisContext,\n\tnode: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\tconst fullPath = cleanSegments.join(\".\");\n\n\t// No identifierSchemas provided at all\n\tif (!ctx.identifierSchemas) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"MISSING_IDENTIFIER_SCHEMAS\",\n\t\t\t\"error\",\n\t\t\t`Property \"${fullPath}:${identifier}\" uses an identifier but no identifier schemas were provided`,\n\t\t\tnode,\n\t\t\t{ path: `${fullPath}:${identifier}`, identifier },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// The identifier does not exist in the provided schemas\n\tconst idSchema = ctx.identifierSchemas[identifier];\n\tif (!idSchema) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_IDENTIFIER\",\n\t\t\t\"error\",\n\t\t\t`Property \"${fullPath}:${identifier}\" references identifier ${identifier} but no schema exists for this identifier`,\n\t\t\tnode,\n\t\t\t{ path: `${fullPath}:${identifier}`, identifier },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// Resolve the path within the identifier's schema\n\tconst resolved = resolveSchemaPath(idSchema, cleanSegments);\n\tif (resolved === undefined) {\n\t\tconst availableProperties = getSchemaPropertyNames(idSchema);\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"IDENTIFIER_PROPERTY_NOT_FOUND\",\n\t\t\t\"error\",\n\t\t\t`Property \"${fullPath}\" does not exist in the schema for identifier ${identifier}`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\tpath: fullPath,\n\t\t\t\tidentifier,\n\t\t\t\tavailableProperties,\n\t\t\t},\n\t\t);\n\t\treturn undefined;\n\t}\n\n\treturn resolved;\n}\n\n// ─── Utilities ───────────────────────────────────────────────────────────────\n\n/**\n * Extracts the first argument of a BlockStatement.\n *\n * In the Handlebars AST, for `{{#if active}}`:\n * - `stmt.path` → PathExpression(\"if\")    ← the helper name\n * - `stmt.params[0]` → PathExpression(\"active\") ← the actual argument\n *\n * @returns The argument expression, or `undefined` if the block has no argument.\n */\n// ─── SubExpression Resolution ────────────────────────────────────────────────\n\n/**\n * Resolves a SubExpression (nested helper call) such as `(lt account.balance 500)`.\n *\n * This mirrors the helper-call logic in `processMustache` but applies to\n * expressions used as arguments (e.g. inside `{{#if (lt a b)}}`).\n *\n * Steps:\n * 1. Extract the helper name from the SubExpression's path.\n * 2. Look up the helper in `ctx.helpers`.\n * 3. Validate argument count and types.\n * 4. Return the helper's declared `returnType` (defaults to `{ type: \"string\" }`).\n */\nfunction resolveSubExpression(\n\texpr: hbs.AST.SubExpression,\n\tctx: AnalysisContext,\n\tparentNode?: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\tconst helperName = getExpressionName(expr.path);\n\n\t// ── Special-case: map helper ─────────────────────────────────────\n\t// The `map` helper requires deep static analysis to infer the\n\t// precise return type `{ type: \"array\", items: <property schema> }`.\n\t// The generic path would only return `{ type: \"array\" }` (the static\n\t// returnType), losing the item schema needed by nested map calls.\n\tif (helperName === MapHelpers.MAP_HELPER_NAME) {\n\t\treturn processMapSubExpression(expr, ctx, parentNode);\n\t}\n\n\tconst helper = ctx.helpers?.get(helperName);\n\tif (!helper) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_HELPER\",\n\t\t\t\"warning\",\n\t\t\t`Unknown sub-expression helper \"${helperName}\" — cannot analyze statically`,\n\t\t\tparentNode ?? expr,\n\t\t\t{ helperName },\n\t\t);\n\t\treturn { type: \"string\" };\n\t}\n\n\tconst helperParams = helper.params;\n\n\t// ── Check the number of required parameters ──────────────────────\n\tif (helperParams) {\n\t\tconst requiredCount = helperParams.filter((p) => !p.optional).length;\n\t\tif (expr.params.length < requiredCount) {\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\"error\",\n\t\t\t\t`Helper \"${helperName}\" expects at least ${requiredCount} argument(s), but got ${expr.params.length}`,\n\t\t\t\tparentNode ?? expr,\n\t\t\t\t{\n\t\t\t\t\thelperName,\n\t\t\t\t\texpected: `${requiredCount} argument(s)`,\n\t\t\t\t\tactual: `${expr.params.length} argument(s)`,\n\t\t\t\t},\n\t\t\t);\n\t\t}\n\t}\n\n\t// ── Validate each parameter (existence + type) ───────────────────\n\tfor (let i = 0; i < expr.params.length; i++) {\n\t\tconst resolvedSchema = resolveExpressionWithDiagnostics(\n\t\t\texpr.params[i] as hbs.AST.Expression,\n\t\t\tctx,\n\t\t\tparentNode ?? expr,\n\t\t);\n\n\t\tconst helperParam = helperParams?.[i];\n\t\tif (resolvedSchema && helperParam?.type) {\n\t\t\tconst expectedType = helperParam.type;\n\t\t\tif (!isParamTypeCompatible(resolvedSchema, expectedType)) {\n\t\t\t\tconst paramName = helperParam.name;\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\t`Helper \"${helperName}\" parameter \"${paramName}\" expects ${schemaTypeLabel(expectedType)}, but got ${schemaTypeLabel(resolvedSchema)}`,\n\t\t\t\t\tparentNode ?? expr,\n\t\t\t\t\t{\n\t\t\t\t\t\thelperName,\n\t\t\t\t\t\texpected: schemaTypeLabel(expectedType),\n\t\t\t\t\t\tactual: schemaTypeLabel(resolvedSchema),\n\t\t\t\t\t},\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn helper.returnType ?? { type: \"string\" };\n}\n\n// ─── map helper — sub-expression analysis ────────────────────────────────────\n// Mirrors processMapHelper but for SubExpression nodes (e.g.\n// `(map users 'cartItems')` used as an argument to another helper).\n// This enables nested map: `{{ map (map users 'cartItems') 'productId' }}`\n\nfunction processMapSubExpression(\n\texpr: hbs.AST.SubExpression,\n\tctx: AnalysisContext,\n\tparentNode?: hbs.AST.Node,\n): JSONSchema7 {\n\tconst helperName = MapHelpers.MAP_HELPER_NAME;\n\tconst node = parentNode ?? expr;\n\n\t// ── 1. Check argument count ──────────────────────────────────────────\n\tif (expr.params.length < 2) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" expects at least 2 argument(s), but got ${expr.params.length}`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"2 argument(s)\",\n\t\t\t\tactual: `${expr.params.length} argument(s)`,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 2. Resolve the first argument (collection path) ──────────────────\n\tconst collectionExpr = expr.params[0] as hbs.AST.Expression;\n\tconst collectionSchema = resolveExpressionWithDiagnostics(\n\t\tcollectionExpr,\n\t\tctx,\n\t\tnode,\n\t);\n\n\tif (!collectionSchema) {\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 3. Validate that the collection is an array ──────────────────────\n\tconst itemSchema = resolveArrayItems(collectionSchema, ctx.root);\n\tif (!itemSchema) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"collection\" expects an array, but got ${schemaTypeLabel(collectionSchema)}`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"array\",\n\t\t\t\tactual: schemaTypeLabel(collectionSchema),\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 4. Validate that the items are objects ───────────────────────────\n\t// If the items are arrays (e.g. from a nested map), flatten one level\n\t// to match the runtime `flat(1)` behavior and use the inner items instead.\n\tlet effectiveItemSchema = itemSchema;\n\tconst itemType = effectiveItemSchema.type;\n\tif (\n\t\titemType === \"array\" ||\n\t\t(Array.isArray(itemType) && itemType.includes(\"array\"))\n\t) {\n\t\tconst innerItems = resolveArrayItems(effectiveItemSchema, ctx.root);\n\t\tif (innerItems) {\n\t\t\teffectiveItemSchema = innerItems;\n\t\t}\n\t}\n\n\tconst effectiveItemType = effectiveItemSchema.type;\n\tconst isObject =\n\t\teffectiveItemType === \"object\" ||\n\t\t(Array.isArray(effectiveItemType) &&\n\t\t\teffectiveItemType.includes(\"object\")) ||\n\t\t(!effectiveItemType && effectiveItemSchema.properties !== undefined);\n\n\tif (!isObject && effectiveItemType !== undefined) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" expects an array of objects, but the array items have type \"${schemaTypeLabel(effectiveItemSchema)}\"`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"object\",\n\t\t\t\tactual: schemaTypeLabel(effectiveItemSchema),\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 5. Validate the second argument (property name) ──────────────────\n\tconst propertyExpr = expr.params[1] as hbs.AST.Expression;\n\tlet propertyName: string | undefined;\n\n\tif (propertyExpr.type === \"PathExpression\") {\n\t\tconst bare = (propertyExpr as hbs.AST.PathExpression).original;\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"property\" must be a quoted string. ` +\n\t\t\t\t`Use (${helperName} … \"${bare}\") instead of (${helperName} … ${bare})`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: 'StringLiteral (e.g. \"property\")',\n\t\t\t\tactual: `PathExpression (${bare})`,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\tif (propertyExpr.type === \"StringLiteral\") {\n\t\tpropertyName = (propertyExpr as hbs.AST.StringLiteral).value;\n\t}\n\n\tif (!propertyName) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"property\" expects a quoted string literal, but got ${propertyExpr.type}`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: 'StringLiteral (e.g. \"property\")',\n\t\t\t\tactual: propertyExpr.type,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 6. Resolve the property within the item schema ───────────────────\n\tconst propertySchema = resolveSchemaPath(effectiveItemSchema, [propertyName]);\n\tif (!propertySchema) {\n\t\tconst availableProperties = getSchemaPropertyNames(effectiveItemSchema);\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_PROPERTY\",\n\t\t\t\"error\",\n\t\t\tcreatePropertyNotFoundMessage(propertyName, availableProperties),\n\t\t\tnode,\n\t\t\t{\n\t\t\t\tpath: propertyName,\n\t\t\t\tavailableProperties,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 7. Return the inferred output schema ─────────────────────────────\n\treturn { type: \"array\", items: propertySchema };\n}\n\nfunction getBlockArgument(\n\tstmt: hbs.AST.BlockStatement,\n): hbs.AST.Expression | undefined {\n\treturn stmt.params[0] as hbs.AST.Expression | undefined;\n}\n\n/**\n * Retrieves the helper name from a BlockStatement (e.g. \"if\", \"each\", \"with\").\n */\nfunction getBlockHelperName(stmt: hbs.AST.BlockStatement): string {\n\tif (stmt.path.type === \"PathExpression\") {\n\t\treturn (stmt.path as hbs.AST.PathExpression).original;\n\t}\n\treturn \"\";\n}\n\n/**\n * Retrieves the name of an expression (first segment of the PathExpression).\n * Used to identify inline helpers.\n */\nfunction getExpressionName(expr: hbs.AST.Expression): string {\n\tif (expr.type === \"PathExpression\") {\n\t\treturn (expr as hbs.AST.PathExpression).original;\n\t}\n\treturn \"\";\n}\n\n/**\n * Adds an enriched diagnostic to the analysis context.\n *\n * Each diagnostic includes:\n * - A machine-readable `code` for the frontend\n * - A human-readable `message` describing the problem\n * - A `source` snippet from the template (if the position is available)\n * - Structured `details` for debugging\n */\nfunction addDiagnostic(\n\tctx: AnalysisContext,\n\tcode: DiagnosticCode,\n\tseverity: \"error\" | \"warning\",\n\tmessage: string,\n\tnode?: hbs.AST.Node,\n\tdetails?: DiagnosticDetails,\n): void {\n\tconst diagnostic: TemplateDiagnostic = { severity, code, message };\n\n\t// Extract the position and source snippet if available\n\tif (node && \"loc\" in node && node.loc) {\n\t\tdiagnostic.loc = {\n\t\t\tstart: { line: node.loc.start.line, column: node.loc.start.column },\n\t\t\tend: { line: node.loc.end.line, column: node.loc.end.column },\n\t\t};\n\t\t// Extract the template fragment around the error\n\t\tdiagnostic.source = extractSourceSnippet(ctx.template, diagnostic.loc);\n\t}\n\n\tif (details) {\n\t\tdiagnostic.details = details;\n\t}\n\n\tctx.diagnostics.push(diagnostic);\n}\n\n/**\n * Returns a human-readable label for a schema's type (for error messages).\n */\nfunction schemaTypeLabel(schema: JSONSchema7): string {\n\tif (schema.type) {\n\t\treturn Array.isArray(schema.type) ? schema.type.join(\" | \") : schema.type;\n\t}\n\tif (schema.oneOf) return \"oneOf(...)\";\n\tif (schema.anyOf) return \"anyOf(...)\";\n\tif (schema.allOf) return \"allOf(...)\";\n\tif (schema.enum) return \"enum\";\n\treturn \"unknown\";\n}\n\n// ─── Export for Internal Use ─────────────────────────────────────────────────\n// `inferBlockType` is exported to allow targeted unit tests\n// on block type inference.\nexport { inferBlockType };\n"],"names":["analyze","analyzeFromAst","inferBlockType","coerceTextValue","text","targetType","undefined","num","Number","isNaN","isInteger","lower","toLowerCase","template","inputSchema","options","dispatchAnalyze","tpl","coerceSchema","ast","parse","identifierSchemas","child","childOptions","ctx","root","current","diagnostics","helpers","conditionalLocations","findConditionalSchemaLocations","loc","addDiagnostic","keyword","schemaPath","path","id","idSchema","Object","entries","idLocations","length","valid","outputSchema","inferProgramType","hasErrors","some","d","severity","simplifySchema","processStatement","stmt","type","processMustache","params","hash","helperName","getExpressionName","MapHelpers","MAP_HELPER_NAME","processMapHelper","helper","get","helperParams","requiredCount","filter","p","optional","expected","actual","i","resolvedSchema","resolveExpressionWithDiagnostics","helperParam","expectedType","isParamTypeCompatible","paramName","name","schemaTypeLabel","returnType","collectionExpr","collectionSchema","itemSchema","resolveArrayItems","effectiveItemSchema","itemType","Array","isArray","includes","innerItems","join","effectiveItemType","isObject","properties","propertyExpr","propertyName","bare","original","value","propertySchema","resolveSchemaPath","availableProperties","getSchemaPropertyNames","createPropertyNotFoundMessage","items","resolved","expectedTypes","resolvedTypes","rt","et","program","effective","getEffectiveBody","singleExpr","getEffectivelySingleExpression","singleBlock","getEffectivelySingleBlock","allContent","every","s","map","trim","coercedType","coercedValue","const","literalType","detectLiteralType","allBlocks","types","t","push","oneOf","body","getBlockHelperName","arg","getBlockArgument","createMissingArgumentMessage","thenType","inverse","elseType","deepEqual","saved","createTypeMismatchMessage","result","innerSchema","param","createUnknownHelperMessage","expr","parentNode","isThisExpression","resolveSubExpression","segments","extractPathSegments","createUnanalyzableMessage","cleanSegments","identifier","extractExpressionIdentifier","isRootPathTraversal","fullPath","createRootPathTraversalMessage","isRootSegments","resolveRootWithIdentifier","resolveWithIdentifier","node","processMapSubExpression","code","message","details","diagnostic","start","line","column","end","source","extractSourceSnippet","schema","anyOf","allOf","enum"],"mappings":"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"}
+{"version":3,"sources":["../../src/analyzer.ts"],"sourcesContent":["import type { JSONSchema7 } from \"json-schema\";\nimport { dispatchAnalyze } from \"./dispatch.ts\";\nimport {\n\tcreateMissingArgumentMessage,\n\tcreatePropertyNotFoundMessage,\n\tcreateRootPathTraversalMessage,\n\tcreateTypeMismatchMessage,\n\tcreateUnanalyzableMessage,\n\tcreateUnknownHelperMessage,\n} from \"./errors\";\nimport { MapHelpers } from \"./helpers/map-helpers.ts\";\nimport {\n\tdetectLiteralType,\n\textractExpressionIdentifier,\n\textractPathSegments,\n\tgetEffectiveBody,\n\tgetEffectivelySingleBlock,\n\tgetEffectivelySingleExpression,\n\tisRootPathTraversal,\n\tisRootSegments,\n\tisThisExpression,\n\tparse,\n} from \"./parser\";\nimport {\n\tfindConditionalSchemaLocations,\n\tresolveArrayItems,\n\tresolveSchemaPath,\n\tsimplifySchema,\n} from \"./schema-resolver\";\nimport type {\n\tAnalysisResult,\n\tDiagnosticCode,\n\tDiagnosticDetails,\n\tHelperDefinition,\n\tTemplateDiagnostic,\n\tTemplateInput,\n} from \"./types.ts\";\nimport {\n\tdeepEqual,\n\textractSourceSnippet,\n\tgetSchemaPropertyNames,\n} from \"./utils\";\n\n// ─── Static Analyzer ─────────────────────────────────────────────────────────\n// Static analysis of a Handlebars template against a JSON Schema v7\n// describing the available context.\n//\n// Merged architecture (v2):\n// A single AST traversal performs both **validation** and **return type\n// inference** simultaneously. This eliminates duplication between the former\n// `validate*` and `infer*` functions and improves performance by avoiding\n// a double traversal.\n//\n// Context:\n// The analysis context uses a **save/restore** pattern instead of creating\n// new objects on each recursion (`{ ...ctx, current: X }`). This reduces\n// GC pressure for deeply nested templates.\n//\n// ─── Template Identifiers ────────────────────────────────────────────────────\n// The `{{key:N}}` syntax allows referencing a variable from a specific\n// schema, identified by an integer N. The optional `identifierSchemas`\n// parameter provides a mapping `{ [id]: JSONSchema7 }`.\n//\n// Resolution rules:\n// - `{{meetingId}}`   → validated against `inputSchema` (standard behavior)\n// - `{{meetingId:1}}` → validated against `identifierSchemas[1]`\n// - `{{meetingId:1}}` without `identifierSchemas[1]` → error\n\n// ─── Internal Types ──────────────────────────────────────────────────────────\n\n/** Context passed recursively during AST traversal */\ninterface AnalysisContext {\n\t/** Root schema (for resolving $refs) */\n\troot: JSONSchema7;\n\t/** Current context schema (changes with #each, #with) — mutated via save/restore */\n\tcurrent: JSONSchema7;\n\t/** Diagnostics accumulator */\n\tdiagnostics: TemplateDiagnostic[];\n\t/** Full template source (for extracting error snippets) */\n\ttemplate: string;\n\t/** Schemas by template identifier (for the {{key:N}} syntax) */\n\tidentifierSchemas?: Record<number, JSONSchema7>;\n\t/** Registered custom helpers (for static analysis) */\n\thelpers?: Map<string, HelperDefinition>;\n\t/**\n\t * Explicit coercion schema provided by the caller.\n\t * When set, static literal values like `\"123\"` will respect the type\n\t * declared in this schema instead of being auto-detected by\n\t * `detectLiteralType`. Unlike the previous `expectedOutputType`,\n\t * this is NEVER derived from the inputSchema — it must be explicitly\n\t * provided via the `coerceSchema` option.\n\t */\n\tcoerceSchema?: JSONSchema7;\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/** Options for the standalone `analyze()` function */\nexport interface AnalyzeOptions {\n\t/** Schemas by template identifier (for the `{{key:N}}` syntax) */\n\tidentifierSchemas?: Record<number, JSONSchema7>;\n\t/**\n\t * Explicit coercion schema. When provided, static literal values\n\t * will respect the types declared in this schema instead of being\n\t * auto-detected by `detectLiteralType`.\n\t *\n\t * This schema is independent from the `inputSchema` (which describes\n\t * available variables) — it only controls the output type inference\n\t * for static content.\n\t */\n\tcoerceSchema?: JSONSchema7;\n\t/**\n\t * When `true`, properties whose values contain Handlebars expressions\n\t * (i.e. any `{{…}}` syntax) are excluded from the output schema.\n\t *\n\t * Only the properties with static values (literals, plain strings\n\t * without expressions) are retained. This is useful when you want\n\t * the output schema to describe only the known, compile-time-constant\n\t * portion of the template.\n\t *\n\t * This option only has an effect on **object** and **array** templates.\n\t * A root-level string template with expressions is analyzed normally\n\t * (there is no parent property to exclude it from).\n\t *\n\t * @default false\n\t */\n\texcludeTemplateExpression?: boolean;\n}\n\n// ─── Coerce Text Value ──────────────────────────────────────────────────────\n\n/**\n * Parses a raw text string into the appropriate JS primitive according to the\n * target JSON Schema type.  Used when `coerceSchema` overrides the default\n * `detectLiteralType` inference for static literal values.\n */\nfunction coerceTextValue(\n\ttext: string,\n\ttargetType: \"string\" | \"number\" | \"integer\" | \"boolean\" | \"null\",\n): string | number | boolean | null | undefined {\n\tswitch (targetType) {\n\t\tcase \"number\":\n\t\tcase \"integer\": {\n\t\t\tif (text === \"\") return undefined;\n\t\t\tconst num = Number(text);\n\t\t\tif (Number.isNaN(num)) return undefined;\n\t\t\tif (targetType === \"integer\" && !Number.isInteger(num)) return undefined;\n\t\t\treturn num;\n\t\t}\n\t\tcase \"boolean\": {\n\t\t\tconst lower = text.toLowerCase();\n\t\t\tif (lower === \"true\") return true;\n\t\t\tif (lower === \"false\") return false;\n\t\t\treturn undefined;\n\t\t}\n\t\tcase \"null\":\n\t\t\treturn null;\n\t\tdefault:\n\t\t\treturn text;\n\t}\n}\n\n/**\n * Statically analyzes a template against a JSON Schema v7 describing the\n * available context.\n *\n * Backward-compatible version — parses the template internally.\n * Uses `dispatchAnalyze` for the recursive array/object/literal dispatching,\n * delegating only the string (template) case to `analyzeFromAst`.\n *\n * @param template           - The template string (e.g. `\"Hello {{user.name}}\"`)\n * @param inputSchema        - JSON Schema v7 describing the available variables\n * @param options            - (optional) Analysis options (identifierSchemas, coerceSchema)\n * @returns An `AnalysisResult` containing validity, diagnostics, and the\n *          inferred output schema.\n */\nexport function analyze(\n\ttemplate: TemplateInput,\n\tinputSchema: JSONSchema7 = {},\n\toptions?: AnalyzeOptions,\n): AnalysisResult {\n\treturn dispatchAnalyze(\n\t\ttemplate,\n\t\toptions,\n\t\t// String handler — parse and analyze the AST\n\t\t(tpl, coerceSchema) => {\n\t\t\tconst ast = parse(tpl);\n\t\t\treturn analyzeFromAst(ast, tpl, inputSchema, {\n\t\t\t\tidentifierSchemas: options?.identifierSchemas,\n\t\t\t\tcoerceSchema,\n\t\t\t});\n\t\t},\n\t\t// Recursive handler — re-enter analyze() for child elements\n\t\t(child, childOptions) => analyze(child, inputSchema, childOptions),\n\t);\n}\n\n/**\n * Statically analyzes a template from an already-parsed AST.\n *\n * This is the internal function used by `Typebars.compile()` and\n * `CompiledTemplate.analyze()` to avoid costly re-parsing.\n *\n * @param ast               - The already-parsed Handlebars AST\n * @param template          - The template source (for error snippets)\n * @param inputSchema       - JSON Schema v7 describing the available variables\n * @param options           - Additional options\n * @returns An `AnalysisResult`\n */\nexport function analyzeFromAst(\n\tast: hbs.AST.Program,\n\ttemplate: string,\n\tinputSchema: JSONSchema7 = {},\n\toptions?: {\n\t\tidentifierSchemas?: Record<number, JSONSchema7>;\n\t\thelpers?: Map<string, HelperDefinition>;\n\t\t/**\n\t\t * Explicit coercion schema. When set, static literal values will\n\t\t * respect the types declared in this schema instead of auto-detecting.\n\t\t * Unlike `expectedOutputType`, this is NEVER derived from inputSchema.\n\t\t */\n\t\tcoerceSchema?: JSONSchema7;\n\t},\n): AnalysisResult {\n\t// ── Initialize the diagnostic context FIRST ────────────────────────\n\tconst ctx: AnalysisContext = {\n\t\troot: inputSchema,\n\t\tcurrent: inputSchema,\n\t\tdiagnostics: [],\n\t\ttemplate,\n\t\tidentifierSchemas: options?.identifierSchemas,\n\t\thelpers: options?.helpers,\n\t\tcoerceSchema: options?.coerceSchema,\n\t};\n\n\t// ── Detect unsupported schema features as diagnostics ──────────────\n\t// Conditional schemas (if/then/else) are non-resolvable without runtime\n\t// data. Instead of throwing, we collect structured diagnostics so the\n\t// caller receives a standard AnalysisResult.\n\tconst conditionalLocations = findConditionalSchemaLocations(inputSchema);\n\tfor (const loc of conditionalLocations) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNSUPPORTED_SCHEMA\",\n\t\t\t\"error\",\n\t\t\t`Unsupported JSON Schema feature: \"${loc.keyword}\" at \"${loc.schemaPath}\". ` +\n\t\t\t\t\"Conditional schemas (if/then/else) cannot be resolved during static analysis \" +\n\t\t\t\t\"because they depend on runtime data. Consider using oneOf/anyOf combinators instead.\",\n\t\t\tundefined,\n\t\t\t{ path: loc.schemaPath },\n\t\t);\n\t}\n\n\tif (options?.identifierSchemas) {\n\t\tfor (const [id, idSchema] of Object.entries(options.identifierSchemas)) {\n\t\t\tconst idLocations = findConditionalSchemaLocations(\n\t\t\t\tidSchema,\n\t\t\t\t`/identifierSchemas/${id}`,\n\t\t\t);\n\t\t\tfor (const loc of idLocations) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"UNSUPPORTED_SCHEMA\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\t`Unsupported JSON Schema feature: \"${loc.keyword}\" at \"${loc.schemaPath}\". ` +\n\t\t\t\t\t\t\"Conditional schemas (if/then/else) cannot be resolved during static analysis \" +\n\t\t\t\t\t\t\"because they depend on runtime data. Consider using oneOf/anyOf combinators instead.\",\n\t\t\t\t\tundefined,\n\t\t\t\t\t{ path: loc.schemaPath },\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\t// If unsupported schemas were found, return early with valid: false\n\tif (ctx.diagnostics.length > 0) {\n\t\treturn {\n\t\t\tvalid: false,\n\t\t\tdiagnostics: ctx.diagnostics,\n\t\t\toutputSchema: {},\n\t\t};\n\t}\n\n\t// Single pass: type inference + validation in one traversal.\n\tconst outputSchema = inferProgramType(ast, ctx);\n\n\tconst hasErrors = ctx.diagnostics.some((d) => d.severity === \"error\");\n\n\treturn {\n\t\tvalid: !hasErrors,\n\t\tdiagnostics: ctx.diagnostics,\n\t\toutputSchema: simplifySchema(outputSchema),\n\t};\n}\n\n// ─── Unified AST Traversal ───────────────────────────────────────────────────\n// A single set of functions handles both validation (emitting diagnostics)\n// and type inference (returning a JSONSchema7).\n//\n// Main functions:\n// - `inferProgramType`   — entry point for a Program (template body or block)\n// - `processStatement`   — dispatches a statement (validation side-effects)\n// - `processMustache`    — handles a MustacheStatement (expression or inline helper)\n// - `inferBlockType`     — handles a BlockStatement (if, each, with, custom…)\n\n/**\n * Dispatches the processing of an individual statement.\n *\n * Called by `inferProgramType` in the \"mixed template\" case to validate\n * each statement while ignoring the returned type (the result is always\n * `string` for a mixed template).\n *\n * @returns The inferred schema for this statement, or `undefined` for\n *          statements with no semantics (ContentStatement, CommentStatement).\n */\nfunction processStatement(\n\tstmt: hbs.AST.Statement,\n\tctx: AnalysisContext,\n): JSONSchema7 | undefined {\n\tswitch (stmt.type) {\n\t\tcase \"ContentStatement\":\n\t\tcase \"CommentStatement\":\n\t\t\t// Static text or comment — nothing to validate, no type to infer\n\t\t\treturn undefined;\n\n\t\tcase \"MustacheStatement\":\n\t\t\treturn processMustache(stmt as hbs.AST.MustacheStatement, ctx);\n\n\t\tcase \"BlockStatement\":\n\t\t\treturn inferBlockType(stmt as hbs.AST.BlockStatement, ctx);\n\n\t\tdefault:\n\t\t\t// Unrecognized AST node — emit a warning rather than an error\n\t\t\t// to avoid blocking on future Handlebars extensions.\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"UNANALYZABLE\",\n\t\t\t\t\"warning\",\n\t\t\t\t`Unsupported AST node type: \"${stmt.type}\"`,\n\t\t\t\tstmt,\n\t\t\t);\n\t\t\treturn undefined;\n\t}\n}\n\n/**\n * Processes a MustacheStatement `{{expression}}` or `{{helper arg}}`.\n *\n * Distinguishes two cases:\n * 1. **Simple expression** (`{{name}}`, `{{user.age}}`) — resolution in the schema\n * 2. **Inline helper** (`{{uppercase name}}`) — params > 0 or hash present\n *\n * @returns The inferred schema for this expression\n */\nfunction processMustache(\n\tstmt: hbs.AST.MustacheStatement,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\t// Sub-expressions (nested helpers) are not supported for static\n\t// analysis — emit a warning.\n\tif (stmt.path.type === \"SubExpression\") {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNANALYZABLE\",\n\t\t\t\"warning\",\n\t\t\t\"Sub-expressions are not statically analyzable\",\n\t\t\tstmt,\n\t\t);\n\t\treturn {};\n\t}\n\n\t// ── Inline helper detection ──────────────────────────────────────────────\n\t// If the MustacheStatement has parameters or a hash, it's a helper call\n\t// (e.g. `{{uppercase name}}`), not a simple expression.\n\tif (stmt.params.length > 0 || stmt.hash) {\n\t\tconst helperName = getExpressionName(stmt.path);\n\n\t\t// ── Special-case: map helper ─────────────────────────────────────\n\t\t// The `map` helper requires deep static analysis that the generic\n\t\t// helper path cannot perform: it must resolve the first argument as\n\t\t// an array-of-objects schema, then resolve the second argument (a\n\t\t// property name) within the item schema to infer the output type\n\t\t// `{ type: \"array\", items: <property schema> }`.\n\t\tif (helperName === MapHelpers.MAP_HELPER_NAME) {\n\t\t\treturn processMapHelper(stmt, ctx);\n\t\t}\n\n\t\t// Check if the helper is registered\n\t\tconst helper = ctx.helpers?.get(helperName);\n\t\tif (helper) {\n\t\t\tconst helperParams = helper.params;\n\n\t\t\t// ── Check the number of required parameters ──────────────\n\t\t\tif (helperParams) {\n\t\t\t\tconst requiredCount = helperParams.filter((p) => !p.optional).length;\n\t\t\t\tif (stmt.params.length < requiredCount) {\n\t\t\t\t\taddDiagnostic(\n\t\t\t\t\t\tctx,\n\t\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\t\"error\",\n\t\t\t\t\t\t`Helper \"${helperName}\" expects at least ${requiredCount} argument(s), but got ${stmt.params.length}`,\n\t\t\t\t\t\tstmt,\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\thelperName,\n\t\t\t\t\t\t\texpected: `${requiredCount} argument(s)`,\n\t\t\t\t\t\t\tactual: `${stmt.params.length} argument(s)`,\n\t\t\t\t\t\t},\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// ── Validate each parameter (existence + type) ───────────────\n\t\t\tfor (let i = 0; i < stmt.params.length; i++) {\n\t\t\t\tconst resolvedSchema = resolveExpressionWithDiagnostics(\n\t\t\t\t\tstmt.params[i] as hbs.AST.Expression,\n\t\t\t\t\tctx,\n\t\t\t\t\tstmt,\n\t\t\t\t);\n\n\t\t\t\t// Check type compatibility if the helper declares the\n\t\t\t\t// expected type for this parameter\n\t\t\t\tconst helperParam = helperParams?.[i];\n\t\t\t\tif (resolvedSchema && helperParam?.type) {\n\t\t\t\t\tconst expectedType = helperParam.type;\n\t\t\t\t\tif (!isParamTypeCompatible(resolvedSchema, expectedType)) {\n\t\t\t\t\t\tconst paramName = helperParam.name;\n\t\t\t\t\t\taddDiagnostic(\n\t\t\t\t\t\t\tctx,\n\t\t\t\t\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\t\t\t\t\"error\",\n\t\t\t\t\t\t\t`Helper \"${helperName}\" parameter \"${paramName}\" expects ${schemaTypeLabel(expectedType)}, but got ${schemaTypeLabel(resolvedSchema)}`,\n\t\t\t\t\t\t\tstmt,\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\thelperName,\n\t\t\t\t\t\t\t\texpected: schemaTypeLabel(expectedType),\n\t\t\t\t\t\t\t\tactual: schemaTypeLabel(resolvedSchema),\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn helper.returnType ?? { type: \"string\" };\n\t\t}\n\n\t\t// Unknown inline helper — warning\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_HELPER\",\n\t\t\t\"warning\",\n\t\t\t`Unknown inline helper \"${helperName}\" — cannot analyze statically`,\n\t\t\tstmt,\n\t\t\t{ helperName },\n\t\t);\n\t\treturn { type: \"string\" };\n\t}\n\n\t// ── Simple expression ────────────────────────────────────────────────────\n\treturn resolveExpressionWithDiagnostics(stmt.path, ctx, stmt) ?? {};\n}\n\n// ─── map helper — special-case analysis ──────────────────────────────────────\n// Validates the arguments and infers the precise return type:\n//   {{ map <arrayPath> <propertyName> }}\n//   → { type: \"array\", items: <schema of the property in the item> }\n//\n// Validation rules:\n// 1. Exactly 2 arguments are required\n// 2. The first argument must resolve to an array schema\n// 3. The array items must be an object schema\n// 4. The second argument must be a string literal (property name)\n// 5. The property must exist in the item schema\n\nfunction processMapHelper(\n\tstmt: hbs.AST.MustacheStatement,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\tconst helperName = MapHelpers.MAP_HELPER_NAME;\n\n\t// ── 1. Check argument count ──────────────────────────────────────────\n\tif (stmt.params.length < 2) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" expects at least 2 argument(s), but got ${stmt.params.length}`,\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"2 argument(s)\",\n\t\t\t\tactual: `${stmt.params.length} argument(s)`,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 2. Resolve the first argument (collection path) ──────────────────\n\tconst collectionExpr = stmt.params[0] as hbs.AST.Expression;\n\tconst collectionSchema = resolveExpressionWithDiagnostics(\n\t\tcollectionExpr,\n\t\tctx,\n\t\tstmt,\n\t);\n\n\tif (!collectionSchema) {\n\t\t// Path resolution failed — diagnostic already emitted\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 3. Validate that the collection is an array ──────────────────────\n\tconst itemSchema = resolveArrayItems(collectionSchema, ctx.root);\n\tif (!itemSchema) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"collection\" expects an array, but got ${schemaTypeLabel(collectionSchema)}`,\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"array\",\n\t\t\t\tactual: schemaTypeLabel(collectionSchema),\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 4. Validate that the items are objects ───────────────────────────\n\t// If the items are arrays (e.g. from a nested map), flatten one level\n\t// to match the runtime `flat(1)` behavior and use the inner items instead.\n\tlet effectiveItemSchema = itemSchema;\n\tconst itemType = effectiveItemSchema.type;\n\tif (\n\t\titemType === \"array\" ||\n\t\t(Array.isArray(itemType) && itemType.includes(\"array\"))\n\t) {\n\t\tconst innerItems = resolveArrayItems(effectiveItemSchema, ctx.root);\n\t\tif (innerItems) {\n\t\t\teffectiveItemSchema = innerItems;\n\t\t\t// Emit an informational warning so consumers know the flatten happened\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"MAP_IMPLICIT_FLATTEN\",\n\t\t\t\t\"warning\",\n\t\t\t\t`The \"${helperName}\" helper will automatically flatten the input array one level before mapping. ` +\n\t\t\t\t\t`The item type \"${Array.isArray(itemType) ? itemType.join(\" | \") : itemType}\" was unwrapped to its inner items schema.`,\n\t\t\t\tstmt,\n\t\t\t\t{\n\t\t\t\t\thelperName,\n\t\t\t\t\texpected: \"object\",\n\t\t\t\t\tactual: schemaTypeLabel(effectiveItemSchema),\n\t\t\t\t},\n\t\t\t);\n\t\t}\n\t}\n\n\tconst effectiveItemType = effectiveItemSchema.type;\n\tconst isObject =\n\t\teffectiveItemType === \"object\" ||\n\t\t(Array.isArray(effectiveItemType) &&\n\t\t\teffectiveItemType.includes(\"object\")) ||\n\t\t// If no type but has properties, treat as object\n\t\t(!effectiveItemType && effectiveItemSchema.properties !== undefined);\n\n\tif (!isObject && effectiveItemType !== undefined) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" expects an array of objects, but the array items have type \"${schemaTypeLabel(effectiveItemSchema)}\"`,\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"object\",\n\t\t\t\tactual: schemaTypeLabel(effectiveItemSchema),\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 5. Validate the second argument (property name) ──────────────────\n\tconst propertyExpr = stmt.params[1] as hbs.AST.Expression;\n\n\t// The property name MUST be a StringLiteral (quoted string like `\"name\"`).\n\t// A bare identifier like `name` is parsed by Handlebars as a PathExpression,\n\t// which would be resolved as a data path at runtime — yielding `undefined`\n\t// when the identifier doesn't exist in the top-level context. This is a\n\t// common mistake, so we provide a clear error message guiding the user.\n\tlet propertyName: string | undefined;\n\n\tif (propertyExpr.type === \"PathExpression\") {\n\t\tconst bare = (propertyExpr as hbs.AST.PathExpression).original;\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"property\" must be a quoted string. ` +\n\t\t\t\t`Use {{ ${helperName} … \"${bare}\" }} instead of {{ ${helperName} … ${bare} }}`,\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: 'StringLiteral (e.g. \"property\")',\n\t\t\t\tactual: `PathExpression (${bare})`,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\tif (propertyExpr.type === \"StringLiteral\") {\n\t\tpropertyName = (propertyExpr as hbs.AST.StringLiteral).value;\n\t}\n\n\tif (!propertyName) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"property\" expects a quoted string literal, but got ${propertyExpr.type}`,\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: 'StringLiteral (e.g. \"property\")',\n\t\t\t\tactual: propertyExpr.type,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 6. Resolve the property within the item schema ───────────────────\n\tconst propertySchema = resolveSchemaPath(effectiveItemSchema, [propertyName]);\n\tif (!propertySchema) {\n\t\tconst availableProperties = getSchemaPropertyNames(effectiveItemSchema);\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_PROPERTY\",\n\t\t\t\"error\",\n\t\t\tcreatePropertyNotFoundMessage(propertyName, availableProperties),\n\t\t\tstmt,\n\t\t\t{\n\t\t\t\tpath: propertyName,\n\t\t\t\tavailableProperties,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 7. Return the inferred output schema ─────────────────────────────\n\treturn { type: \"array\", items: propertySchema };\n}\n\n/**\n * Checks whether a resolved type is compatible with the type expected\n * by a helper parameter.\n *\n * Compatibility rules:\n * - If either schema has no `type`, validation is not possible → compatible\n * - `integer` is compatible with `number` (integer ⊂ number)\n * - For multiple types (e.g. `[\"string\", \"number\"]`), at least one resolved\n *   type must match one expected type\n */\nfunction isParamTypeCompatible(\n\tresolved: JSONSchema7,\n\texpected: JSONSchema7,\n): boolean {\n\t// If either has no type info, we cannot validate\n\tif (!expected.type || !resolved.type) return true;\n\n\tconst expectedTypes = Array.isArray(expected.type)\n\t\t? expected.type\n\t\t: [expected.type];\n\tconst resolvedTypes = Array.isArray(resolved.type)\n\t\t? resolved.type\n\t\t: [resolved.type];\n\n\t// At least one resolved type must be compatible with one expected type\n\treturn resolvedTypes.some((rt) =>\n\t\texpectedTypes.some(\n\t\t\t(et) =>\n\t\t\t\trt === et ||\n\t\t\t\t// integer is a subtype of number\n\t\t\t\t(et === \"number\" && rt === \"integer\") ||\n\t\t\t\t(et === \"integer\" && rt === \"number\"),\n\t\t),\n\t);\n}\n\n/**\n * Infers the output type of a `Program` (template body or block body).\n *\n * Handles 4 cases, from most specific to most general:\n *\n * 1. **Single expression** `{{expr}}` → type of the expression\n * 2. **Single block** `{{#if}}…{{/if}}` → type of the block\n * 3. **Pure text content** → literal detection (number, boolean, null)\n * 4. **Mixed template** → always `string` (concatenation)\n *\n * Validation is performed alongside inference: each expression and block\n * is validated during processing.\n */\nfunction inferProgramType(\n\tprogram: hbs.AST.Program,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\tconst effective = getEffectiveBody(program);\n\n\t// No significant statements → empty string\n\tif (effective.length === 0) {\n\t\treturn { type: \"string\" };\n\t}\n\n\t// ── Case 1: single expression {{expr}} ─────────────────────────────────\n\tconst singleExpr = getEffectivelySingleExpression(program);\n\tif (singleExpr) {\n\t\treturn processMustache(singleExpr, ctx);\n\t}\n\n\t// ── Case 2: single block {{#if}}, {{#each}}, {{#with}}, … ──────────────\n\tconst singleBlock = getEffectivelySingleBlock(program);\n\tif (singleBlock) {\n\t\treturn inferBlockType(singleBlock, ctx);\n\t}\n\n\t// ── Case 3: only ContentStatements (no expressions) ────────────────────\n\t// If the concatenated (trimmed) text is a typed literal (number, boolean,\n\t// null), we infer the corresponding type.\n\tconst allContent = effective.every((s) => s.type === \"ContentStatement\");\n\tif (allContent) {\n\t\tconst text = effective\n\t\t\t.map((s) => (s as hbs.AST.ContentStatement).value)\n\t\t\t.join(\"\")\n\t\t\t.trim();\n\n\t\tif (text === \"\") return { type: \"string\" };\n\n\t\t// If an explicit coerceSchema was provided and declares a specific\n\t\t// primitive type, respect it instead of auto-detecting. For example,\n\t\t// \"123\" with coerceSchema `{ type: \"string\" }` should stay \"string\".\n\t\t// This only applies when coerceSchema is explicitly set — the\n\t\t// inputSchema is NEVER used for coercion.\n\t\t//\n\t\t// Only the **type** is extracted from coerceSchema. Value-level\n\t\t// constraints (enum, const, format, pattern, minLength, …) are NOT\n\t\t// propagated because they describe what the *consumer* accepts, not\n\t\t// what the literal *produces*. The actual literal value is set as\n\t\t// `const` so downstream compatibility checkers can detect mismatches.\n\t\tconst coercedType = ctx.coerceSchema?.type;\n\t\tif (\n\t\t\ttypeof coercedType === \"string\" &&\n\t\t\t(coercedType === \"string\" ||\n\t\t\t\tcoercedType === \"number\" ||\n\t\t\t\tcoercedType === \"integer\" ||\n\t\t\t\tcoercedType === \"boolean\" ||\n\t\t\t\tcoercedType === \"null\")\n\t\t) {\n\t\t\tconst coercedValue = coerceTextValue(text, coercedType);\n\t\t\treturn { type: coercedType, const: coercedValue } as JSONSchema7;\n\t\t}\n\n\t\tconst literalType = detectLiteralType(text);\n\t\tif (literalType) return { type: literalType };\n\t}\n\n\t// ── Case 4: multiple blocks only (no significant text between them) ────\n\t// When the effective body consists entirely of BlockStatements, gather\n\t// each block's inferred type and combine them via oneOf. This handles\n\t// templates like:\n\t//   {{#if showName}}{{name}}{{/if}}\n\t//   {{#if showAge}}{{age}}{{/if}}\n\t// where the output could be string OR number depending on which branch\n\t// is active.\n\tconst allBlocks = effective.every((s) => s.type === \"BlockStatement\");\n\tif (allBlocks) {\n\t\tconst types: JSONSchema7[] = [];\n\t\tfor (const stmt of effective) {\n\t\t\tconst t = inferBlockType(stmt as hbs.AST.BlockStatement, ctx);\n\t\t\tif (t) types.push(t);\n\t\t}\n\t\tif (types.length === 1) return types[0] as JSONSchema7;\n\t\tif (types.length > 1) return simplifySchema({ oneOf: types });\n\t\treturn { type: \"string\" };\n\t}\n\n\t// ── Case 5: mixed template (text + expressions, blocks…) ───────────────\n\t// Traverse all statements for validation (side-effects: diagnostics).\n\t// The result is always string (concatenation).\n\tfor (const stmt of program.body) {\n\t\tprocessStatement(stmt, ctx);\n\t}\n\treturn { type: \"string\" };\n}\n\n/**\n * Infers the output type of a BlockStatement and validates its content.\n *\n * Supports built-in helpers (`if`, `unless`, `each`, `with`) and custom\n * helpers registered via `Typebars.registerHelper()`.\n *\n * Uses the **save/restore** pattern for context: instead of creating a new\n * object `{ ...ctx, current: X }` on each recursion, we save `ctx.current`,\n * mutate it, process the body, then restore. This reduces GC pressure for\n * deeply nested templates.\n */\nfunction inferBlockType(\n\tstmt: hbs.AST.BlockStatement,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\tconst helperName = getBlockHelperName(stmt);\n\n\tswitch (helperName) {\n\t\t// ── if / unless ──────────────────────────────────────────────────────\n\t\t// Validate the condition argument, then infer types from both branches.\n\t\tcase \"if\":\n\t\tcase \"unless\": {\n\t\t\tconst arg = getBlockArgument(stmt);\n\t\t\tif (arg) {\n\t\t\t\tresolveExpressionWithDiagnostics(arg, ctx, stmt);\n\t\t\t} else {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateMissingArgumentMessage(helperName),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{ helperName },\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Infer the type of the \"then\" branch\n\t\t\tconst thenType = inferProgramType(stmt.program, ctx);\n\n\t\t\tif (stmt.inverse) {\n\t\t\t\tconst elseType = inferProgramType(stmt.inverse, ctx);\n\t\t\t\t// If both branches have the same type → single type\n\t\t\t\tif (deepEqual(thenType, elseType)) return thenType;\n\t\t\t\t// Otherwise → union of both types\n\t\t\t\treturn simplifySchema({ oneOf: [thenType, elseType] });\n\t\t\t}\n\n\t\t\t// No else branch → the result is the type of the then branch\n\t\t\t// (conceptually optional, but Handlebars returns \"\" for falsy)\n\t\t\treturn thenType;\n\t\t}\n\n\t\t// ── each ─────────────────────────────────────────────────────────────\n\t\t// Resolve the collection schema, then validate the body with the item\n\t\t// schema as the new context.\n\t\tcase \"each\": {\n\t\t\tconst arg = getBlockArgument(stmt);\n\t\t\tif (!arg) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateMissingArgumentMessage(\"each\"),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{ helperName: \"each\" },\n\t\t\t\t);\n\t\t\t\t// Validate the body with an empty context (best-effort)\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn { type: \"string\" };\n\t\t\t}\n\n\t\t\tconst collectionSchema = resolveExpressionWithDiagnostics(arg, ctx, stmt);\n\t\t\tif (!collectionSchema) {\n\t\t\t\t// The path could not be resolved — diagnostic already emitted.\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn { type: \"string\" };\n\t\t\t}\n\n\t\t\t// Resolve the schema of the array elements\n\t\t\tconst itemSchema = resolveArrayItems(collectionSchema, ctx.root);\n\t\t\tif (!itemSchema) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateTypeMismatchMessage(\n\t\t\t\t\t\t\"each\",\n\t\t\t\t\t\t\"an array\",\n\t\t\t\t\t\tschemaTypeLabel(collectionSchema),\n\t\t\t\t\t),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{\n\t\t\t\t\t\thelperName: \"each\",\n\t\t\t\t\t\texpected: \"array\",\n\t\t\t\t\t\tactual: schemaTypeLabel(collectionSchema),\n\t\t\t\t\t},\n\t\t\t\t);\n\t\t\t\t// Validate the body with an empty context (best-effort)\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn { type: \"string\" };\n\t\t\t}\n\n\t\t\t// Validate the body with the item schema as the new context\n\t\t\tconst saved = ctx.current;\n\t\t\tctx.current = itemSchema;\n\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\tctx.current = saved;\n\n\t\t\t// The inverse branch ({{else}}) keeps the parent context\n\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\n\t\t\t// An each concatenates renders → always string\n\t\t\treturn { type: \"string\" };\n\t\t}\n\n\t\t// ── with ─────────────────────────────────────────────────────────────\n\t\t// Resolve the inner schema, then validate the body with it as the\n\t\t// new context.\n\t\tcase \"with\": {\n\t\t\tconst arg = getBlockArgument(stmt);\n\t\t\tif (!arg) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateMissingArgumentMessage(\"with\"),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{ helperName: \"with\" },\n\t\t\t\t);\n\t\t\t\t// Validate the body with an empty context\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tconst result = inferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn result;\n\t\t\t}\n\n\t\t\tconst innerSchema = resolveExpressionWithDiagnostics(arg, ctx, stmt);\n\n\t\t\tconst saved = ctx.current;\n\t\t\tctx.current = innerSchema ?? {};\n\t\t\tconst result = inferProgramType(stmt.program, ctx);\n\t\t\tctx.current = saved;\n\n\t\t\t// The inverse branch keeps the parent context\n\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\n\t\t\treturn result;\n\t\t}\n\n\t\t// ── Custom or unknown helper ─────────────────────────────────────────\n\t\tdefault: {\n\t\t\tconst helper = ctx.helpers?.get(helperName);\n\t\t\tif (helper) {\n\t\t\t\t// Registered custom helper — validate parameters\n\t\t\t\tfor (const param of stmt.params) {\n\t\t\t\t\tresolveExpressionWithDiagnostics(\n\t\t\t\t\t\tparam as hbs.AST.Expression,\n\t\t\t\t\t\tctx,\n\t\t\t\t\t\tstmt,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\t// Validate the body with the current context\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn helper.returnType ?? { type: \"string\" };\n\t\t\t}\n\n\t\t\t// Unknown helper — warning\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"UNKNOWN_HELPER\",\n\t\t\t\t\"warning\",\n\t\t\t\tcreateUnknownHelperMessage(helperName),\n\t\t\t\tstmt,\n\t\t\t\t{ helperName },\n\t\t\t);\n\t\t\t// Still validate the body with the current context (best-effort)\n\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\treturn { type: \"string\" };\n\t\t}\n\t}\n}\n\n// ─── Expression Resolution ───────────────────────────────────────────────────\n\n/**\n * Resolves an AST expression to a sub-schema, emitting a diagnostic\n * if the path cannot be resolved.\n *\n * Handles the `{{key:N}}` syntax:\n * - If the expression has an identifier N → resolution in `identifierSchemas[N]`\n * - If identifier N has no associated schema → error\n * - If no identifier → resolution in `ctx.current` (standard behavior)\n *\n * @returns The resolved sub-schema, or `undefined` if the path is invalid.\n */\nfunction resolveExpressionWithDiagnostics(\n\texpr: hbs.AST.Expression,\n\tctx: AnalysisContext,\n\t/** Parent AST node (for diagnostic location) */\n\tparentNode?: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\t// Handle `this` / `.` → return the current context\n\tif (isThisExpression(expr)) {\n\t\treturn ctx.current;\n\t}\n\n\t// ── SubExpression (nested helper call, e.g. `(lt account.balance 500)`) ──\n\tif (expr.type === \"SubExpression\") {\n\t\treturn resolveSubExpression(expr as hbs.AST.SubExpression, ctx, parentNode);\n\t}\n\n\tconst segments = extractPathSegments(expr);\n\tif (segments.length === 0) {\n\t\t// Expression that is not a PathExpression (e.g. literal)\n\t\tif (expr.type === \"StringLiteral\") return { type: \"string\" };\n\t\tif (expr.type === \"NumberLiteral\") return { type: \"number\" };\n\t\tif (expr.type === \"BooleanLiteral\") return { type: \"boolean\" };\n\t\tif (expr.type === \"NullLiteral\") return { type: \"null\" };\n\t\tif (expr.type === \"UndefinedLiteral\") return {};\n\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNANALYZABLE\",\n\t\t\t\"warning\",\n\t\t\tcreateUnanalyzableMessage(expr.type),\n\t\t\tparentNode ?? expr,\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// ── Identifier extraction ──────────────────────────────────────────────\n\t// Extract the `:N` suffix BEFORE checking for `$root` so that both\n\t// `{{$root}}` and `{{$root:2}}` are handled uniformly.\n\tconst { cleanSegments, identifier } = extractExpressionIdentifier(segments);\n\n\t// ── $root token ──────────────────────────────────────────────────────\n\t// Path traversal ($root.name, $root.address.city) is always forbidden,\n\t// regardless of whether an identifier is present.\n\tif (isRootPathTraversal(cleanSegments)) {\n\t\tconst fullPath = cleanSegments.join(\".\");\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"ROOT_PATH_TRAVERSAL\",\n\t\t\t\"error\",\n\t\t\tcreateRootPathTraversalMessage(fullPath),\n\t\t\tparentNode ?? expr,\n\t\t\t{ path: fullPath },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// `{{$root}}` → return the entire current context schema\n\t// `{{$root:N}}` → return the entire schema for identifier N\n\tif (isRootSegments(cleanSegments)) {\n\t\tif (identifier !== null) {\n\t\t\treturn resolveRootWithIdentifier(identifier, ctx, parentNode ?? expr);\n\t\t}\n\t\treturn ctx.current;\n\t}\n\n\tif (identifier !== null) {\n\t\t// The expression uses the {{key:N}} syntax — resolve from\n\t\t// the schema of identifier N.\n\t\treturn resolveWithIdentifier(\n\t\t\tcleanSegments,\n\t\t\tidentifier,\n\t\t\tctx,\n\t\t\tparentNode ?? expr,\n\t\t);\n\t}\n\n\t// ── Standard resolution (no identifier) ────────────────────────────────\n\tconst resolved = resolveSchemaPath(ctx.current, cleanSegments);\n\tif (resolved === undefined) {\n\t\tconst fullPath = cleanSegments.join(\".\");\n\t\tconst availableProperties = getSchemaPropertyNames(ctx.current);\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_PROPERTY\",\n\t\t\t\"error\",\n\t\t\tcreatePropertyNotFoundMessage(fullPath, availableProperties),\n\t\t\tparentNode ?? expr,\n\t\t\t{ path: fullPath, availableProperties },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\treturn resolved;\n}\n\n/**\n * Resolves `{{$root:N}}` — returns the **entire** schema for identifier N.\n *\n * This is the identifier-aware counterpart of returning `ctx.current` for\n * a plain `{{$root}}`. Instead of navigating into properties, it returns\n * the identifier's root schema directly.\n *\n * When the identifier schema is an array (aggregated multi-version data),\n * the full array schema is returned as-is — the caller receives the\n * complete `{ type: \"array\", items: ... }` schema.\n *\n * Emits an error diagnostic if:\n * - No `identifierSchemas` were provided\n * - Identifier N has no associated schema\n */\nfunction resolveRootWithIdentifier(\n\tidentifier: number,\n\tctx: AnalysisContext,\n\tnode: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\t// No identifierSchemas provided at all\n\tif (!ctx.identifierSchemas) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"MISSING_IDENTIFIER_SCHEMAS\",\n\t\t\t\"error\",\n\t\t\t`Property \"$root:${identifier}\" uses an identifier but no identifier schemas were provided`,\n\t\t\tnode,\n\t\t\t{ path: `$root:${identifier}`, identifier },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// The identifier does not exist in the provided schemas\n\tconst idSchema = ctx.identifierSchemas[identifier];\n\tif (!idSchema) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_IDENTIFIER\",\n\t\t\t\"error\",\n\t\t\t`Property \"$root:${identifier}\" references identifier ${identifier} but no schema exists for this identifier`,\n\t\t\tnode,\n\t\t\t{ path: `$root:${identifier}`, identifier },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// Return the entire schema for identifier N.\n\t// For aggregated identifiers (array schemas), this returns the full\n\t// array schema — e.g. { type: \"array\", items: { type: \"object\", ... } }\n\treturn idSchema;\n}\n\n/**\n * Resolves an expression with identifier `{{key:N}}` by looking up the\n * schema associated with identifier N.\n *\n * When the identifier schema is an array (aggregated multi-version data),\n * the property is resolved within the array's `items` schema, and the\n * result is wrapped in `{ type: \"array\", items: <resolved> }`. This\n * models the runtime behavior where `{{accountId:4}}` on an array of\n * objects extracts the property from each element, producing an array.\n *\n * Emits an error diagnostic if:\n * - No `identifierSchemas` were provided\n * - Identifier N has no associated schema\n * - The property does not exist in the identifier's schema\n */\nfunction resolveWithIdentifier(\n\tcleanSegments: string[],\n\tidentifier: number,\n\tctx: AnalysisContext,\n\tnode: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\tconst fullPath = cleanSegments.join(\".\");\n\n\t// No identifierSchemas provided at all\n\tif (!ctx.identifierSchemas) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"MISSING_IDENTIFIER_SCHEMAS\",\n\t\t\t\"error\",\n\t\t\t`Property \"${fullPath}:${identifier}\" uses an identifier but no identifier schemas were provided`,\n\t\t\tnode,\n\t\t\t{ path: `${fullPath}:${identifier}`, identifier },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// The identifier does not exist in the provided schemas\n\tconst idSchema = ctx.identifierSchemas[identifier];\n\tif (!idSchema) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_IDENTIFIER\",\n\t\t\t\"error\",\n\t\t\t`Property \"${fullPath}:${identifier}\" references identifier ${identifier} but no schema exists for this identifier`,\n\t\t\tnode,\n\t\t\t{ path: `${fullPath}:${identifier}`, identifier },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// ── Aggregated identifier (array schema) ─────────────────────────────\n\t// When the identifier schema is an array of objects (e.g. from a\n\t// multi-versioned workflow node), resolve the property within the\n\t// items schema and wrap the result in an array type.\n\t//\n\t// Example: identifierSchemas[4] = { type: \"array\", items: { type: \"object\",\n\t//   properties: { accountId: { type: \"string\" } } } }\n\t// Expression: {{accountId:4}}\n\t// Result: { type: \"array\", items: { type: \"string\" } }\n\tconst itemSchema = resolveArrayItems(idSchema, ctx.root);\n\tif (itemSchema !== undefined) {\n\t\t// The identifier schema is an array — resolve within items\n\t\tconst resolved = resolveSchemaPath(itemSchema, cleanSegments);\n\t\tif (resolved === undefined) {\n\t\t\tconst availableProperties = getSchemaPropertyNames(itemSchema);\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"IDENTIFIER_PROPERTY_NOT_FOUND\",\n\t\t\t\t\"error\",\n\t\t\t\t`Property \"${fullPath}\" does not exist in the items schema for identifier ${identifier}`,\n\t\t\t\tnode,\n\t\t\t\t{\n\t\t\t\t\tpath: fullPath,\n\t\t\t\t\tidentifier,\n\t\t\t\t\tavailableProperties,\n\t\t\t\t},\n\t\t\t);\n\t\t\treturn undefined;\n\t\t}\n\t\t// Wrap the resolved property schema in an array\n\t\treturn { type: \"array\", items: resolved };\n\t}\n\n\t// ── Standard identifier (single object schema) ───────────────────────\n\t// Resolve the path within the identifier's schema directly.\n\tconst resolved = resolveSchemaPath(idSchema, cleanSegments);\n\tif (resolved === undefined) {\n\t\tconst availableProperties = getSchemaPropertyNames(idSchema);\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"IDENTIFIER_PROPERTY_NOT_FOUND\",\n\t\t\t\"error\",\n\t\t\t`Property \"${fullPath}\" does not exist in the schema for identifier ${identifier}`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\tpath: fullPath,\n\t\t\t\tidentifier,\n\t\t\t\tavailableProperties,\n\t\t\t},\n\t\t);\n\t\treturn undefined;\n\t}\n\n\treturn resolved;\n}\n\n// ─── Utilities ───────────────────────────────────────────────────────────────\n\n/**\n * Extracts the first argument of a BlockStatement.\n *\n * In the Handlebars AST, for `{{#if active}}`:\n * - `stmt.path` → PathExpression(\"if\")    ← the helper name\n * - `stmt.params[0]` → PathExpression(\"active\") ← the actual argument\n *\n * @returns The argument expression, or `undefined` if the block has no argument.\n */\n// ─── SubExpression Resolution ────────────────────────────────────────────────\n\n/**\n * Resolves a SubExpression (nested helper call) such as `(lt account.balance 500)`.\n *\n * This mirrors the helper-call logic in `processMustache` but applies to\n * expressions used as arguments (e.g. inside `{{#if (lt a b)}}`).\n *\n * Steps:\n * 1. Extract the helper name from the SubExpression's path.\n * 2. Look up the helper in `ctx.helpers`.\n * 3. Validate argument count and types.\n * 4. Return the helper's declared `returnType` (defaults to `{ type: \"string\" }`).\n */\nfunction resolveSubExpression(\n\texpr: hbs.AST.SubExpression,\n\tctx: AnalysisContext,\n\tparentNode?: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\tconst helperName = getExpressionName(expr.path);\n\n\t// ── Special-case: map helper ─────────────────────────────────────\n\t// The `map` helper requires deep static analysis to infer the\n\t// precise return type `{ type: \"array\", items: <property schema> }`.\n\t// The generic path would only return `{ type: \"array\" }` (the static\n\t// returnType), losing the item schema needed by nested map calls.\n\tif (helperName === MapHelpers.MAP_HELPER_NAME) {\n\t\treturn processMapSubExpression(expr, ctx, parentNode);\n\t}\n\n\tconst helper = ctx.helpers?.get(helperName);\n\tif (!helper) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_HELPER\",\n\t\t\t\"warning\",\n\t\t\t`Unknown sub-expression helper \"${helperName}\" — cannot analyze statically`,\n\t\t\tparentNode ?? expr,\n\t\t\t{ helperName },\n\t\t);\n\t\treturn { type: \"string\" };\n\t}\n\n\tconst helperParams = helper.params;\n\n\t// ── Check the number of required parameters ──────────────────────\n\tif (helperParams) {\n\t\tconst requiredCount = helperParams.filter((p) => !p.optional).length;\n\t\tif (expr.params.length < requiredCount) {\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\"error\",\n\t\t\t\t`Helper \"${helperName}\" expects at least ${requiredCount} argument(s), but got ${expr.params.length}`,\n\t\t\t\tparentNode ?? expr,\n\t\t\t\t{\n\t\t\t\t\thelperName,\n\t\t\t\t\texpected: `${requiredCount} argument(s)`,\n\t\t\t\t\tactual: `${expr.params.length} argument(s)`,\n\t\t\t\t},\n\t\t\t);\n\t\t}\n\t}\n\n\t// ── Validate each parameter (existence + type) ───────────────────\n\tfor (let i = 0; i < expr.params.length; i++) {\n\t\tconst resolvedSchema = resolveExpressionWithDiagnostics(\n\t\t\texpr.params[i] as hbs.AST.Expression,\n\t\t\tctx,\n\t\t\tparentNode ?? expr,\n\t\t);\n\n\t\tconst helperParam = helperParams?.[i];\n\t\tif (resolvedSchema && helperParam?.type) {\n\t\t\tconst expectedType = helperParam.type;\n\t\t\tif (!isParamTypeCompatible(resolvedSchema, expectedType)) {\n\t\t\t\tconst paramName = helperParam.name;\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\t`Helper \"${helperName}\" parameter \"${paramName}\" expects ${schemaTypeLabel(expectedType)}, but got ${schemaTypeLabel(resolvedSchema)}`,\n\t\t\t\t\tparentNode ?? expr,\n\t\t\t\t\t{\n\t\t\t\t\t\thelperName,\n\t\t\t\t\t\texpected: schemaTypeLabel(expectedType),\n\t\t\t\t\t\tactual: schemaTypeLabel(resolvedSchema),\n\t\t\t\t\t},\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn helper.returnType ?? { type: \"string\" };\n}\n\n// ─── map helper — sub-expression analysis ────────────────────────────────────\n// Mirrors processMapHelper but for SubExpression nodes (e.g.\n// `(map users 'cartItems')` used as an argument to another helper).\n// This enables nested map: `{{ map (map users 'cartItems') 'productId' }}`\n\nfunction processMapSubExpression(\n\texpr: hbs.AST.SubExpression,\n\tctx: AnalysisContext,\n\tparentNode?: hbs.AST.Node,\n): JSONSchema7 {\n\tconst helperName = MapHelpers.MAP_HELPER_NAME;\n\tconst node = parentNode ?? expr;\n\n\t// ── 1. Check argument count ──────────────────────────────────────────\n\tif (expr.params.length < 2) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" expects at least 2 argument(s), but got ${expr.params.length}`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"2 argument(s)\",\n\t\t\t\tactual: `${expr.params.length} argument(s)`,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 2. Resolve the first argument (collection path) ──────────────────\n\tconst collectionExpr = expr.params[0] as hbs.AST.Expression;\n\tconst collectionSchema = resolveExpressionWithDiagnostics(\n\t\tcollectionExpr,\n\t\tctx,\n\t\tnode,\n\t);\n\n\tif (!collectionSchema) {\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 3. Validate that the collection is an array ──────────────────────\n\tconst itemSchema = resolveArrayItems(collectionSchema, ctx.root);\n\tif (!itemSchema) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"collection\" expects an array, but got ${schemaTypeLabel(collectionSchema)}`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"array\",\n\t\t\t\tactual: schemaTypeLabel(collectionSchema),\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 4. Validate that the items are objects ───────────────────────────\n\t// If the items are arrays (e.g. from a nested map), flatten one level\n\t// to match the runtime `flat(1)` behavior and use the inner items instead.\n\tlet effectiveItemSchema = itemSchema;\n\tconst itemType = effectiveItemSchema.type;\n\tif (\n\t\titemType === \"array\" ||\n\t\t(Array.isArray(itemType) && itemType.includes(\"array\"))\n\t) {\n\t\tconst innerItems = resolveArrayItems(effectiveItemSchema, ctx.root);\n\t\tif (innerItems) {\n\t\t\teffectiveItemSchema = innerItems;\n\t\t}\n\t}\n\n\tconst effectiveItemType = effectiveItemSchema.type;\n\tconst isObject =\n\t\teffectiveItemType === \"object\" ||\n\t\t(Array.isArray(effectiveItemType) &&\n\t\t\teffectiveItemType.includes(\"object\")) ||\n\t\t(!effectiveItemType && effectiveItemSchema.properties !== undefined);\n\n\tif (!isObject && effectiveItemType !== undefined) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" expects an array of objects, but the array items have type \"${schemaTypeLabel(effectiveItemSchema)}\"`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: \"object\",\n\t\t\t\tactual: schemaTypeLabel(effectiveItemSchema),\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 5. Validate the second argument (property name) ──────────────────\n\tconst propertyExpr = expr.params[1] as hbs.AST.Expression;\n\tlet propertyName: string | undefined;\n\n\tif (propertyExpr.type === \"PathExpression\") {\n\t\tconst bare = (propertyExpr as hbs.AST.PathExpression).original;\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"property\" must be a quoted string. ` +\n\t\t\t\t`Use (${helperName} … \"${bare}\") instead of (${helperName} … ${bare})`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: 'StringLiteral (e.g. \"property\")',\n\t\t\t\tactual: `PathExpression (${bare})`,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\tif (propertyExpr.type === \"StringLiteral\") {\n\t\tpropertyName = (propertyExpr as hbs.AST.StringLiteral).value;\n\t}\n\n\tif (!propertyName) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\"error\",\n\t\t\t`Helper \"${helperName}\" parameter \"property\" expects a quoted string literal, but got ${propertyExpr.type}`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\thelperName,\n\t\t\t\texpected: 'StringLiteral (e.g. \"property\")',\n\t\t\t\tactual: propertyExpr.type,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 6. Resolve the property within the item schema ───────────────────\n\tconst propertySchema = resolveSchemaPath(effectiveItemSchema, [propertyName]);\n\tif (!propertySchema) {\n\t\tconst availableProperties = getSchemaPropertyNames(effectiveItemSchema);\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_PROPERTY\",\n\t\t\t\"error\",\n\t\t\tcreatePropertyNotFoundMessage(propertyName, availableProperties),\n\t\t\tnode,\n\t\t\t{\n\t\t\t\tpath: propertyName,\n\t\t\t\tavailableProperties,\n\t\t\t},\n\t\t);\n\t\treturn { type: \"array\" };\n\t}\n\n\t// ── 7. Return the inferred output schema ─────────────────────────────\n\treturn { type: \"array\", items: propertySchema };\n}\n\nfunction getBlockArgument(\n\tstmt: hbs.AST.BlockStatement,\n): hbs.AST.Expression | undefined {\n\treturn stmt.params[0] as hbs.AST.Expression | undefined;\n}\n\n/**\n * Retrieves the helper name from a BlockStatement (e.g. \"if\", \"each\", \"with\").\n */\nfunction getBlockHelperName(stmt: hbs.AST.BlockStatement): string {\n\tif (stmt.path.type === \"PathExpression\") {\n\t\treturn (stmt.path as hbs.AST.PathExpression).original;\n\t}\n\treturn \"\";\n}\n\n/**\n * Retrieves the name of an expression (first segment of the PathExpression).\n * Used to identify inline helpers.\n */\nfunction getExpressionName(expr: hbs.AST.Expression): string {\n\tif (expr.type === \"PathExpression\") {\n\t\treturn (expr as hbs.AST.PathExpression).original;\n\t}\n\treturn \"\";\n}\n\n/**\n * Adds an enriched diagnostic to the analysis context.\n *\n * Each diagnostic includes:\n * - A machine-readable `code` for the frontend\n * - A human-readable `message` describing the problem\n * - A `source` snippet from the template (if the position is available)\n * - Structured `details` for debugging\n */\nfunction addDiagnostic(\n\tctx: AnalysisContext,\n\tcode: DiagnosticCode,\n\tseverity: \"error\" | \"warning\",\n\tmessage: string,\n\tnode?: hbs.AST.Node,\n\tdetails?: DiagnosticDetails,\n): void {\n\tconst diagnostic: TemplateDiagnostic = { severity, code, message };\n\n\t// Extract the position and source snippet if available\n\tif (node && \"loc\" in node && node.loc) {\n\t\tdiagnostic.loc = {\n\t\t\tstart: { line: node.loc.start.line, column: node.loc.start.column },\n\t\t\tend: { line: node.loc.end.line, column: node.loc.end.column },\n\t\t};\n\t\t// Extract the template fragment around the error\n\t\tdiagnostic.source = extractSourceSnippet(ctx.template, diagnostic.loc);\n\t}\n\n\tif (details) {\n\t\tdiagnostic.details = details;\n\t}\n\n\tctx.diagnostics.push(diagnostic);\n}\n\n/**\n * Returns a human-readable label for a schema's type (for error messages).\n */\nfunction schemaTypeLabel(schema: JSONSchema7): string {\n\tif (schema.type) {\n\t\treturn Array.isArray(schema.type) ? schema.type.join(\" | \") : schema.type;\n\t}\n\tif (schema.oneOf) return \"oneOf(...)\";\n\tif (schema.anyOf) return \"anyOf(...)\";\n\tif (schema.allOf) return \"allOf(...)\";\n\tif (schema.enum) return \"enum\";\n\treturn \"unknown\";\n}\n\n// ─── Export for Internal Use ─────────────────────────────────────────────────\n// `inferBlockType` is exported to allow targeted unit tests\n// on block type inference.\nexport { inferBlockType };\n"],"names":["analyze","analyzeFromAst","inferBlockType","coerceTextValue","text","targetType","undefined","num","Number","isNaN","isInteger","lower","toLowerCase","template","inputSchema","options","dispatchAnalyze","tpl","coerceSchema","ast","parse","identifierSchemas","child","childOptions","ctx","root","current","diagnostics","helpers","conditionalLocations","findConditionalSchemaLocations","loc","addDiagnostic","keyword","schemaPath","path","id","idSchema","Object","entries","idLocations","length","valid","outputSchema","inferProgramType","hasErrors","some","d","severity","simplifySchema","processStatement","stmt","type","processMustache","params","hash","helperName","getExpressionName","MapHelpers","MAP_HELPER_NAME","processMapHelper","helper","get","helperParams","requiredCount","filter","p","optional","expected","actual","i","resolvedSchema","resolveExpressionWithDiagnostics","helperParam","expectedType","isParamTypeCompatible","paramName","name","schemaTypeLabel","returnType","collectionExpr","collectionSchema","itemSchema","resolveArrayItems","effectiveItemSchema","itemType","Array","isArray","includes","innerItems","join","effectiveItemType","isObject","properties","propertyExpr","propertyName","bare","original","value","propertySchema","resolveSchemaPath","availableProperties","getSchemaPropertyNames","createPropertyNotFoundMessage","items","resolved","expectedTypes","resolvedTypes","rt","et","program","effective","getEffectiveBody","singleExpr","getEffectivelySingleExpression","singleBlock","getEffectivelySingleBlock","allContent","every","s","map","trim","coercedType","coercedValue","const","literalType","detectLiteralType","allBlocks","types","t","push","oneOf","body","getBlockHelperName","arg","getBlockArgument","createMissingArgumentMessage","thenType","inverse","elseType","deepEqual","saved","createTypeMismatchMessage","result","innerSchema","param","createUnknownHelperMessage","expr","parentNode","isThisExpression","resolveSubExpression","segments","extractPathSegments","createUnanalyzableMessage","cleanSegments","identifier","extractExpressionIdentifier","isRootPathTraversal","fullPath","createRootPathTraversalMessage","isRootSegments","resolveRootWithIdentifier","resolveWithIdentifier","node","processMapSubExpression","code","message","details","diagnostic","start","line","column","end","source","extractSourceSnippet","schema","anyOf","allOf","enum"],"mappings":"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"}

package/dist/cjs/compiled-template.d.ts

@@ -1,7 +1,7 @@
 import type Handlebars from "handlebars";
 import type { JSONSchema7 } from "json-schema";
 import type { AnalyzeOptions } from "./analyzer.js";
-import type { AnalysisResult, ExecuteOptions, HelperDefinition, TemplateData, ValidationResult } from "./types.js";
+import type { AnalysisResult, ExecuteOptions, HelperDefinition, IdentifierData, TemplateData, ValidationResult } from "./types.js";
 import { type LRUCache } from "./utils.js";
 /** Internal options passed by Typebars during compilation */
 export interface CompiledTemplateOptions {
@@ -118,7 +118,7 @@ export declare class CompiledTemplate {
      */
     analyzeAndExecute(inputSchema: JSONSchema7 | undefined, data: TemplateData, options?: {
         identifierSchemas?: Record<number, JSONSchema7>;
-        identifierData?: Record<number, Record<string, unknown>>;
+        identifierData?: IdentifierData;
         coerceSchema?: JSONSchema7;
     }): {
         analysis: AnalysisResult;