typebars 1.0.9 → 1.0.11

package/README.md

@@ -79,6 +79,7 @@ The output schema is inferred **statically** from the template structure and the
   - [`registerHelper`](#registerhelper)
   - [`defineHelper` (Type-Safe)](#definehelper-type-safe)
 - [Template Identifiers (`{{key:N}}`)](#template-identifiers-keyn)
+- [Output Type Coercion (`coerceSchema`)](#output-type-coercion-coerceschema)
 - [Error Handling](#error-handling)
 - [Configuration & API Reference](#configuration--api-reference)
 
@@ -1348,7 +1349,7 @@ The `{{key:N}}` syntax references variables from **different data sources**, ide
 
 ### Analysis with Identifier Schemas
 
-Each identifier maps to its own JSON Schema:
+Each identifier maps to its own JSON Schema. Pass them via the `options` object:
 
 ```ts
 const engine = new Typebars();
@@ -1367,15 +1368,15 @@ const identifierSchemas = {
 };
 
 // ✅ Valid — meetingId exists in identifier 1's schema
-engine.analyze("{{meetingId:1}}", inputSchema, identifierSchemas);
+engine.analyze("{{meetingId:1}}", inputSchema, { identifierSchemas });
 // → valid: true, outputSchema: { type: "string" }
 
 // ❌ Invalid — identifier 1 doesn't have "badKey"
-engine.analyze("{{badKey:1}}", inputSchema, identifierSchemas);
+engine.analyze("{{badKey:1}}", inputSchema, { identifierSchemas });
 // → valid: false, code: IDENTIFIER_PROPERTY_NOT_FOUND
 
 // ❌ Invalid — identifier 99 doesn't exist
-engine.analyze("{{meetingId:99}}", inputSchema, identifierSchemas);
+engine.analyze("{{meetingId:99}}", inputSchema, { identifierSchemas });
 // → valid: false, code: UNKNOWN_IDENTIFIER
 
 // ❌ Invalid — identifiers used but no schemas provided
@@ -1401,7 +1402,9 @@ const idSchemas = {
 };
 
 // ✅ "name" validated against schema, "meetingId:1" against idSchemas[1]
-engine.analyze("{{name}} — {{meetingId:1}}", schema, idSchemas);
+engine.analyze("{{name}} — {{meetingId:1}}", schema, {
+  identifierSchemas: idSchemas,
+});
 // → valid: true
 ```
 
@@ -1451,6 +1454,142 @@ value;                 // 99.95
 
 ---
 
+## Output Type Coercion (`coerceSchema`)
+
+By default, static literal values in templates are auto-detected by `detectLiteralType`:
+- `"123"` → `number`
+- `"true"` → `boolean`
+- `"null"` → `null`
+- `"hello"` → `string`
+
+The `inputSchema` **never** influences this detection. However, you can provide an explicit `coerceSchema` in the options to override the output type inference for static literals.
+
+### Why `coerceSchema`?
+
+When building objects from templates, you may want to force the output type of a static value to match a specific schema — for example, keeping `"123"` as a `string` instead of auto-detecting it as `number`. The `coerceSchema` is a **separate source of truth** from `inputSchema`, which avoids false positives in validation.
+
+### Basic Usage
+
+```ts
+const engine = new Typebars();
+
+// Without coerceSchema — "123" is auto-detected as number
+engine.analyze("123", { type: "string" });
+// → outputSchema: { type: "number" }
+
+// With coerceSchema — "123" respects the coercion schema
+engine.analyze("123", { type: "string" }, {
+  coerceSchema: { type: "string" },
+});
+// → outputSchema: { type: "string" }
+```
+
+### Object Templates with `coerceSchema`
+
+For object templates, `coerceSchema` is resolved per-property and propagated recursively through nested objects:
+
+```ts
+const inputSchema = {
+  type: "object",
+  properties: {
+    userName: { type: "string" },
+  },
+};
+
+const coerceSchema = {
+  type: "object",
+  properties: {
+    meetingId: { type: "string" },
+    config: {
+      type: "object",
+      properties: {
+        retries: { type: "string" },
+      },
+    },
+  },
+};
+
+const result = engine.analyze(
+  {
+    meetingId: "12345",        // coerceSchema says string → stays string
+    count: "42",               // not in coerceSchema → detectLiteralType → number
+    label: "{{userName}}",     // Handlebars expression → resolved from inputSchema
+    config: {
+      retries: "3",            // coerceSchema says string → stays string
+    },
+  },
+  inputSchema,
+  { coerceSchema },
+);
+
+result.outputSchema;
+// → {
+//   type: "object",
+//   properties: {
+//     meetingId: { type: "string" },  ← coerced
+//     count:     { type: "number" },  ← auto-detected
+//     label:     { type: "string" },  ← from inputSchema
+//     config: {
+//       type: "object",
+//       properties: {
+//         retries: { type: "string" },  ← coerced (deep propagation)
+//       },
+//       required: ["retries"],
+//     },
+//   },
+//   required: ["meetingId", "count", "label", "config"],
+// }
+```
+
+### Rules
+
+| Scenario | Output type |
+|----------|-------------|
+| Static literal, no `coerceSchema` | `detectLiteralType` (e.g. `"123"` → `number`) |
+| Static literal, `coerceSchema` with primitive type | Respects `coerceSchema` type |
+| Static literal, `coerceSchema` with non-primitive type (object, array) | Falls back to `detectLiteralType` |
+| Static literal, `coerceSchema` with no `type` | Falls back to `detectLiteralType` |
+| Handlebars expression (`{{expr}}`) | Always resolved from `inputSchema` — `coerceSchema` ignored |
+| Mixed template (`text + {{expr}}`) | Always `string` — `coerceSchema` ignored |
+| JS primitive literal (`42`, `true`, `null`) | Always `inferPrimitiveSchema` — `coerceSchema` ignored |
+| Property not in `coerceSchema` | Falls back to `detectLiteralType` |
+
+### With `analyzeAndExecute`
+
+`coerceSchema` also works with `analyzeAndExecute`:
+
+```ts
+const { analysis, value } = engine.analyzeAndExecute(
+  { meetingId: "12345", name: "{{userName}}" },
+  inputSchema,
+  { userName: "Alice" },
+  {
+    coerceSchema: {
+      type: "object",
+      properties: { meetingId: { type: "string" } },
+    },
+  },
+);
+
+analysis.outputSchema;
+// → { type: "object", properties: { meetingId: { type: "string" }, name: { type: "string" } }, ... }
+value;
+// → { meetingId: "12345", name: "Alice" }
+```
+
+### Standalone `analyze()` Function
+
+The standalone `analyze()` function from `src/analyzer.ts` also accepts `coerceSchema`:
+
+```ts
+import { analyze } from "typebars/analyzer";
+
+analyze("123", { type: "string" }, { coerceSchema: { type: "string" } });
+// → outputSchema: { type: "string" }
+```
+
+---
+
 ## Error Handling
 
 ### `TemplateParseError`
@@ -1542,10 +1681,10 @@ type TemplateInput =
 
 | Method | Description |
 |--------|-------------|
-| `analyze(template, inputSchema, identifierSchemas?)` | Validates template + infers output schema. Returns `AnalysisResult` |
-| `validate(template, inputSchema, identifierSchemas?)` | Like `analyze()` but without `outputSchema`. Returns `ValidationResult` |
+| `analyze(template, inputSchema, options?)` | Validates template + infers output schema. Options: `{ identifierSchemas?, coerceSchema? }`. Returns `AnalysisResult` |
+| `validate(template, inputSchema, options?)` | Like `analyze()` but without `outputSchema`. Returns `ValidationResult` |
 | `execute(template, data, options?)` | Renders the template. Options: `{ schema?, identifierData?, identifierSchemas? }` |
-| `analyzeAndExecute(template, inputSchema, data, options?)` | Analyze + execute in one call. Returns `{ analysis, value }` |
+| `analyzeAndExecute(template, inputSchema, data, options?)` | Analyze + execute in one call. Options: `{ identifierSchemas?, identifierData?, coerceSchema? }`. Returns `{ analysis, value }` |
 | `compile(template)` | Returns a `CompiledTemplate` (parse-once, execute-many) |
 | `isValidSyntax(template)` | Syntax check only (no schema needed). Returns `boolean` |
 | `registerHelper(name, definition)` | Register a custom helper. Returns `this` |
@@ -1553,6 +1692,15 @@ type TemplateInput =
 | `hasHelper(name)` | Check if a helper is registered |
 | `clearCaches()` | Clear all internal caches |
 
+### `AnalyzeOptions`
+
+```ts
+interface AnalyzeOptions {
+  identifierSchemas?: Record<number, JSONSchema7>; // schemas by identifier
+  coerceSchema?: JSONSchema7;                      // output type coercion
+}
+```
+
 ### `AnalysisResult`
 
 ```ts

package/dist/cjs/analyzer.d.ts

@@ -14,6 +14,30 @@ interface AnalysisContext {
     identifierSchemas?: Record<number, JSONSchema7>;
     /** Registered custom helpers (for static analysis) */
     helpers?: Map<string, HelperDefinition>;
+    /**
+     * Explicit coercion schema provided by the caller.
+     * When set, static literal values like `"123"` will respect the type
+     * declared in this schema instead of being auto-detected by
+     * `detectLiteralType`. Unlike the previous `expectedOutputType`,
+     * this is NEVER derived from the inputSchema — it must be explicitly
+     * provided via the `coerceSchema` option.
+     */
+    coerceSchema?: JSONSchema7;
+}
+/** Options for the standalone `analyze()` function */
+export interface AnalyzeOptions {
+    /** Schemas by template identifier (for the `{{key:N}}` syntax) */
+    identifierSchemas?: Record<number, JSONSchema7>;
+    /**
+     * Explicit coercion schema. When provided, static literal values
+     * will respect the types declared in this schema instead of being
+     * auto-detected by `detectLiteralType`.
+     *
+     * This schema is independent from the `inputSchema` (which describes
+     * available variables) — it only controls the output type inference
+     * for static content.
+     */
+    coerceSchema?: JSONSchema7;
 }
 /**
  * Statically analyzes a template against a JSON Schema v7 describing the
@@ -23,11 +47,11 @@ interface AnalysisContext {
  *
  * @param template           - The template string (e.g. `"Hello {{user.name}}"`)
  * @param inputSchema        - JSON Schema v7 describing the available variables
- * @param identifierSchemas  - (optional) Schemas by identifier `{ [id]: JSONSchema7 }`
+ * @param options            - (optional) Analysis options (identifierSchemas, coerceSchema)
  * @returns An `AnalysisResult` containing validity, diagnostics, and the
  *          inferred output schema.
  */
-export declare function analyze(template: TemplateInput, inputSchema: JSONSchema7, identifierSchemas?: Record<number, JSONSchema7>): AnalysisResult;
+export declare function analyze(template: TemplateInput, inputSchema: JSONSchema7, options?: AnalyzeOptions): AnalysisResult;
 /**
  * Statically analyzes a template from an already-parsed AST.
  *
@@ -43,6 +67,12 @@ export declare function analyze(template: TemplateInput, inputSchema: JSONSchema
 export declare function analyzeFromAst(ast: hbs.AST.Program, template: string, inputSchema: JSONSchema7, options?: {
     identifierSchemas?: Record<number, JSONSchema7>;
     helpers?: Map<string, HelperDefinition>;
+    /**
+     * Explicit coercion schema. When set, static literal values will
+     * respect the types declared in this schema instead of auto-detecting.
+     * Unlike `expectedOutputType`, this is NEVER derived from inputSchema.
+     */
+    coerceSchema?: JSONSchema7;
 }): AnalysisResult;
 /**
  * Infers the output type of a BlockStatement and validates its content.

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 _errors=require("./errors.js");const _parser=require("./parser.js");const _schemaresolver=require("./schema-resolver.js");const _typests=require("./types.js");const _utils=require("./utils.js");function analyze(template,inputSchema,identifierSchemas){if((0,_typests.isArrayInput)(template)){return analyzeArrayTemplate(template,inputSchema,identifierSchemas)}if((0,_typests.isObjectInput)(template)){return analyzeObjectTemplate(template,inputSchema,identifierSchemas)}if((0,_typests.isLiteralInput)(template)){return{valid:true,diagnostics:[],outputSchema:(0,_typests.inferPrimitiveSchema)(template)}}const ast=(0,_parser.parse)(template);return analyzeFromAst(ast,template,inputSchema,{identifierSchemas})}function analyzeArrayTemplate(template,inputSchema,identifierSchemas){return(0,_utils.aggregateArrayAnalysis)(template.length,index=>analyze(template[index],inputSchema,identifierSchemas))}function analyzeObjectTemplate(template,inputSchema,identifierSchemas){return(0,_utils.aggregateObjectAnalysis)(Object.keys(template),key=>analyze(template[key],inputSchema,identifierSchemas))}function analyzeFromAst(ast,template,inputSchema,options){(0,_schemaresolver.assertNoConditionalSchema)(inputSchema);if(options?.identifierSchemas){for(const[id,idSchema]of Object.entries(options.identifierSchemas)){(0,_schemaresolver.assertNoConditionalSchema)(idSchema,`/identifierSchemas/${id}`)}}const ctx={root:inputSchema,current:inputSchema,diagnostics:[],template,identifierSchemas:options?.identifierSchemas,helpers:options?.helpers};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);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 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 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(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 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);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 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 _errors=require("./errors.js");const _parser=require("./parser.js");const _schemaresolver=require("./schema-resolver.js");const _typests=require("./types.js");const _utils=require("./utils.js");function analyze(template,inputSchema,options){if((0,_typests.isArrayInput)(template)){return analyzeArrayTemplate(template,inputSchema,options)}if((0,_typests.isObjectInput)(template)){return analyzeObjectTemplate(template,inputSchema,options)}if((0,_typests.isLiteralInput)(template)){return{valid:true,diagnostics:[],outputSchema:(0,_typests.inferPrimitiveSchema)(template)}}const ast=(0,_parser.parse)(template);return analyzeFromAst(ast,template,inputSchema,{identifierSchemas:options?.identifierSchemas,coerceSchema:options?.coerceSchema})}function analyzeArrayTemplate(template,inputSchema,options){return(0,_utils.aggregateArrayAnalysis)(template.length,index=>analyze(template[index],inputSchema,options))}function analyzeObjectTemplate(template,inputSchema,options){const coerceSchema=options?.coerceSchema;return(0,_utils.aggregateObjectAnalysis)(Object.keys(template),key=>{const childCoerceSchema=coerceSchema?(0,_schemaresolver.resolveSchemaPath)(coerceSchema,[key]):undefined;return analyze(template[key],inputSchema,{identifierSchemas:options?.identifierSchemas,coerceSchema:childCoerceSchema})})}function analyzeFromAst(ast,template,inputSchema,options){(0,_schemaresolver.assertNoConditionalSchema)(inputSchema);if(options?.identifierSchemas){for(const[id,idSchema]of Object.entries(options.identifierSchemas)){(0,_schemaresolver.assertNoConditionalSchema)(idSchema,`/identifierSchemas/${id}`)}}const ctx={root:inputSchema,current:inputSchema,diagnostics:[],template,identifierSchemas:options?.identifierSchemas,helpers:options?.helpers,coerceSchema:options?.coerceSchema};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);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 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")){return{type:coercedType}}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(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 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);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 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 {\n\tcreateMissingArgumentMessage,\n\tcreatePropertyNotFoundMessage,\n\tcreateTypeMismatchMessage,\n\tcreateUnanalyzableMessage,\n\tcreateUnknownHelperMessage,\n} from \"./errors\";\nimport {\n\tdetectLiteralType,\n\textractExpressionIdentifier,\n\textractPathSegments,\n\tgetEffectiveBody,\n\tgetEffectivelySingleBlock,\n\tgetEffectivelySingleExpression,\n\tisThisExpression,\n\tparse,\n} from \"./parser\";\nimport {\n\tassertNoConditionalSchema,\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\tTemplateInputArray,\n\tTemplateInputObject,\n} from \"./types.ts\";\nimport {\n\tinferPrimitiveSchema,\n\tisArrayInput,\n\tisLiteralInput,\n\tisObjectInput,\n} from \"./types.ts\";\nimport {\n\taggregateArrayAnalysis,\n\taggregateObjectAnalysis,\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}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\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 *\n * @param template           - The template string (e.g. `\"Hello {{user.name}}\"`)\n * @param inputSchema        - JSON Schema v7 describing the available variables\n * @param identifierSchemas  - (optional) Schemas by identifier `{ [id]: JSONSchema7 }`\n * @returns An `AnalysisResult` containing validity, diagnostics, and the\n *          inferred output schema.\n */\nexport function analyze(\n\ttemplate: TemplateInput,\n\tinputSchema: JSONSchema7,\n\tidentifierSchemas?: Record<number, JSONSchema7>,\n): AnalysisResult {\n\tif (isArrayInput(template)) {\n\t\treturn analyzeArrayTemplate(template, inputSchema, identifierSchemas);\n\t}\n\tif (isObjectInput(template)) {\n\t\treturn analyzeObjectTemplate(template, inputSchema, identifierSchemas);\n\t}\n\tif (isLiteralInput(template)) {\n\t\treturn {\n\t\t\tvalid: true,\n\t\t\tdiagnostics: [],\n\t\t\toutputSchema: inferPrimitiveSchema(template),\n\t\t};\n\t}\n\tconst ast = parse(template);\n\treturn analyzeFromAst(ast, template, inputSchema, { identifierSchemas });\n}\n\n/**\n * Analyzes an array template recursively (standalone version).\n * Each element is analyzed individually, diagnostics are merged,\n * and the `outputSchema` reflects the array structure with a proper `items`.\n */\nfunction analyzeArrayTemplate(\n\ttemplate: TemplateInputArray,\n\tinputSchema: JSONSchema7,\n\tidentifierSchemas?: Record<number, JSONSchema7>,\n): AnalysisResult {\n\treturn aggregateArrayAnalysis(template.length, (index) =>\n\t\tanalyze(template[index] as TemplateInput, inputSchema, identifierSchemas),\n\t);\n}\n\n/**\n * Analyzes an object template recursively (standalone version).\n * Each property is analyzed individually, diagnostics are merged,\n * and the `outputSchema` reflects the object structure.\n */\nfunction analyzeObjectTemplate(\n\ttemplate: TemplateInputObject,\n\tinputSchema: JSONSchema7,\n\tidentifierSchemas?: Record<number, JSONSchema7>,\n): AnalysisResult {\n\treturn aggregateObjectAnalysis(Object.keys(template), (key) =>\n\t\tanalyze(template[key] as TemplateInput, inputSchema, identifierSchemas),\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},\n): AnalysisResult {\n\t// ── Reject unsupported schema features before analysis ────────────\n\t// Conditional schemas (if/then/else) are non-resolvable without runtime\n\t// data. Fail fast with a clear error rather than producing silently\n\t// incorrect results.\n\tassertNoConditionalSchema(inputSchema);\n\n\tif (options?.identifierSchemas) {\n\t\tfor (const [id, idSchema] of Object.entries(options.identifierSchemas)) {\n\t\t\tassertNoConditionalSchema(idSchema, `/identifierSchemas/${id}`);\n\t\t}\n\t}\n\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};\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// 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/**\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\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, collect\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\tconst { cleanSegments, identifier } = extractExpressionIdentifier(segments);\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 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\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\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","template","inputSchema","identifierSchemas","isArrayInput","analyzeArrayTemplate","isObjectInput","analyzeObjectTemplate","isLiteralInput","valid","diagnostics","outputSchema","inferPrimitiveSchema","ast","parse","aggregateArrayAnalysis","length","index","aggregateObjectAnalysis","Object","keys","key","options","assertNoConditionalSchema","id","idSchema","entries","ctx","root","current","helpers","inferProgramType","hasErrors","some","d","severity","simplifySchema","processStatement","stmt","type","undefined","processMustache","addDiagnostic","path","params","hash","helperName","getExpressionName","helper","get","helperParams","requiredCount","filter","p","optional","expected","actual","i","resolvedSchema","resolveExpressionWithDiagnostics","helperParam","expectedType","isParamTypeCompatible","paramName","name","schemaTypeLabel","returnType","resolved","expectedTypes","Array","isArray","resolvedTypes","rt","et","program","effective","getEffectiveBody","singleExpr","getEffectivelySingleExpression","singleBlock","getEffectivelySingleBlock","allContent","every","s","text","map","value","join","trim","literalType","detectLiteralType","allBlocks","types","t","push","oneOf","body","getBlockHelperName","arg","getBlockArgument","createMissingArgumentMessage","thenType","inverse","elseType","deepEqual","saved","collectionSchema","itemSchema","resolveArrayItems","createTypeMismatchMessage","result","innerSchema","param","createUnknownHelperMessage","expr","parentNode","isThisExpression","resolveSubExpression","segments","extractPathSegments","createUnanalyzableMessage","cleanSegments","identifier","extractExpressionIdentifier","resolveWithIdentifier","resolveSchemaPath","fullPath","availableProperties","getSchemaPropertyNames","createPropertyNotFoundMessage","node","original","code","message","details","diagnostic","loc","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 {\n\tcreateMissingArgumentMessage,\n\tcreatePropertyNotFoundMessage,\n\tcreateTypeMismatchMessage,\n\tcreateUnanalyzableMessage,\n\tcreateUnknownHelperMessage,\n} from \"./errors\";\nimport {\n\tdetectLiteralType,\n\textractExpressionIdentifier,\n\textractPathSegments,\n\tgetEffectiveBody,\n\tgetEffectivelySingleBlock,\n\tgetEffectivelySingleExpression,\n\tisThisExpression,\n\tparse,\n} from \"./parser\";\nimport {\n\tassertNoConditionalSchema,\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\tTemplateInputArray,\n\tTemplateInputObject,\n} from \"./types.ts\";\nimport {\n\tinferPrimitiveSchema,\n\tisArrayInput,\n\tisLiteralInput,\n\tisObjectInput,\n} from \"./types.ts\";\nimport {\n\taggregateArrayAnalysis,\n\taggregateObjectAnalysis,\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}\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 *\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\tif (isArrayInput(template)) {\n\t\treturn analyzeArrayTemplate(template, inputSchema, options);\n\t}\n\tif (isObjectInput(template)) {\n\t\treturn analyzeObjectTemplate(template, inputSchema, options);\n\t}\n\tif (isLiteralInput(template)) {\n\t\treturn {\n\t\t\tvalid: true,\n\t\t\tdiagnostics: [],\n\t\t\toutputSchema: inferPrimitiveSchema(template),\n\t\t};\n\t}\n\tconst ast = parse(template);\n\treturn analyzeFromAst(ast, template, inputSchema, {\n\t\tidentifierSchemas: options?.identifierSchemas,\n\t\tcoerceSchema: options?.coerceSchema,\n\t});\n}\n\n/**\n * Analyzes an array template recursively (standalone version).\n * Each element is analyzed individually, diagnostics are merged,\n * and the `outputSchema` reflects the array structure with a proper `items`.\n */\nfunction analyzeArrayTemplate(\n\ttemplate: TemplateInputArray,\n\tinputSchema: JSONSchema7,\n\toptions?: AnalyzeOptions,\n): AnalysisResult {\n\treturn aggregateArrayAnalysis(template.length, (index) =>\n\t\tanalyze(template[index] as TemplateInput, inputSchema, options),\n\t);\n}\n\n/**\n * Analyzes an object template recursively (standalone version).\n * Each property is analyzed individually, diagnostics are merged,\n * and the `outputSchema` reflects the object structure.\n */\nfunction analyzeObjectTemplate(\n\ttemplate: TemplateInputObject,\n\tinputSchema: JSONSchema7,\n\toptions?: AnalyzeOptions,\n): AnalysisResult {\n\tconst coerceSchema = options?.coerceSchema;\n\treturn aggregateObjectAnalysis(Object.keys(template), (key) => {\n\t\t// When a coerceSchema is provided, resolve the child property schema\n\t\t// from the coercion schema. This allows deeply nested objects to\n\t\t// propagate coercion at every level.\n\t\tconst childCoerceSchema = coerceSchema\n\t\t\t? resolveSchemaPath(coerceSchema, [key])\n\t\t\t: undefined;\n\t\treturn analyze(template[key] as TemplateInput, inputSchema, {\n\t\t\tidentifierSchemas: options?.identifierSchemas,\n\t\t\tcoerceSchema: childCoerceSchema,\n\t\t});\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// ── Reject unsupported schema features before analysis ────────────\n\t// Conditional schemas (if/then/else) are non-resolvable without runtime\n\t// data. Fail fast with a clear error rather than producing silently\n\t// incorrect results.\n\tassertNoConditionalSchema(inputSchema);\n\n\tif (options?.identifierSchemas) {\n\t\tfor (const [id, idSchema] of Object.entries(options.identifierSchemas)) {\n\t\t\tassertNoConditionalSchema(idSchema, `/identifierSchemas/${id}`);\n\t\t}\n\t}\n\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// 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// 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/**\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\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\treturn { type: coercedType };\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, collect\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\tconst { cleanSegments, identifier } = extractExpressionIdentifier(segments);\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 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\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\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","template","inputSchema","options","isArrayInput","analyzeArrayTemplate","isObjectInput","analyzeObjectTemplate","isLiteralInput","valid","diagnostics","outputSchema","inferPrimitiveSchema","ast","parse","identifierSchemas","coerceSchema","aggregateArrayAnalysis","length","index","aggregateObjectAnalysis","Object","keys","key","childCoerceSchema","resolveSchemaPath","undefined","assertNoConditionalSchema","id","idSchema","entries","ctx","root","current","helpers","inferProgramType","hasErrors","some","d","severity","simplifySchema","processStatement","stmt","type","processMustache","addDiagnostic","path","params","hash","helperName","getExpressionName","helper","get","helperParams","requiredCount","filter","p","optional","expected","actual","i","resolvedSchema","resolveExpressionWithDiagnostics","helperParam","expectedType","isParamTypeCompatible","paramName","name","schemaTypeLabel","returnType","resolved","expectedTypes","Array","isArray","resolvedTypes","rt","et","program","effective","getEffectiveBody","singleExpr","getEffectivelySingleExpression","singleBlock","getEffectivelySingleBlock","allContent","every","s","text","map","value","join","trim","coercedType","literalType","detectLiteralType","allBlocks","types","t","push","oneOf","body","getBlockHelperName","arg","getBlockArgument","createMissingArgumentMessage","thenType","inverse","elseType","deepEqual","saved","collectionSchema","itemSchema","resolveArrayItems","createTypeMismatchMessage","result","innerSchema","param","createUnknownHelperMessage","expr","parentNode","isThisExpression","resolveSubExpression","segments","extractPathSegments","createUnanalyzableMessage","cleanSegments","identifier","extractExpressionIdentifier","resolveWithIdentifier","fullPath","availableProperties","getSchemaPropertyNames","createPropertyNotFoundMessage","node","original","code","message","details","diagnostic","loc","start","line","column","end","source","extractSourceSnippet","schema","anyOf","allOf","enum"],"mappings":"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"}