@stacksjs/stx 0.2.95 → 0.2.96

package/dist/types.js

@@ -1,2 +1 @@
-// @bun
-import"./chunk-vx22he47.js";import{If as a}from"./chunk-yywfvfph.js";import"./chunk-xv34zbp4.js";export{a as isDirectiveKind};
+export * from "./types/index.js";

package/dist/typescript-templates.js

@@ -1,4 +1,386 @@
-// @bun
-import"./chunk-xv34zbp4.js";function $(G){let q=G.trim();if(["string","number","boolean","null","undefined","any","unknown","never","void"].includes(q))return{kind:"primitive",value:q};if(q.endsWith("[]"))return{kind:"array",elementType:$(q.slice(0,-2))};if(q.startsWith("Array<")&&q.endsWith(">"))return{kind:"array",elementType:$(q.slice(6,-1))};if(q.includes("|")&&!q.startsWith("{")&&!q.startsWith("("))return{kind:"union",types:V(q,"|").map((J)=>$(J))};if(q.includes("&")&&!q.startsWith("{")&&!q.startsWith("("))return{kind:"intersection",types:V(q,"&").map((J)=>$(J))};if(q.startsWith("'")&&q.endsWith("'")||q.startsWith('"')&&q.endsWith('"'))return{kind:"literal",literalValue:q.slice(1,-1)};if(/^\d+$/.test(q))return{kind:"literal",literalValue:Number.parseInt(q)};if(q==="true"||q==="false")return{kind:"literal",literalValue:q==="true"};if(q.startsWith("{")&&q.endsWith("}"))return k(q);if(q.includes("=>"))return P(q);if(q.includes("<")&&q.endsWith(">")){let H=q.indexOf("<"),J=q.slice(0,H),L=q.slice(H+1,-1),Q=F(L).map((U)=>$(U));return{kind:"generic",value:J,typeArguments:Q}}return{kind:"reference",value:q}}function k(G){let q=G.slice(1,-1).trim(),z={};if(!q)return{kind:"object",properties:z};let H=O(q);for(let J of H){let L=J.trim();if(!L)continue;let Q=L.startsWith("readonly "),U=Q?L.slice(9):L,W=U.indexOf(":");if(W===-1)continue;let Y=U.slice(0,W).trim(),Z=U.slice(W+1).trim(),K=Y.endsWith("?");if(K)Y=Y.slice(0,-1);z[Y]={type:$(Z),optional:K,readonly:Q}}return{kind:"object",properties:z}}function P(G){let q=G.indexOf("=>"),z=G.slice(0,q).trim(),H=G.slice(q+2).trim(),J=[];if(z.startsWith("(")&&z.endsWith(")")){let L=z.slice(1,-1),Q=F(L);for(let U of Q){let W=U.trim();if(!W)continue;let Y=W.startsWith("..."),Z=Y?W.slice(3):W,K=Z.indexOf(":");if(K===-1)J.push({name:Z,type:{kind:"primitive",value:"any"},optional:!1,rest:Y});else{let X=Z.slice(0,K).trim(),E=Z.slice(K+1).trim(),j=X.endsWith("?");if(j)X=X.slice(0,-1);J.push({name:X,type:$(E),optional:j,rest:Y})}}}return{kind:"function",parameters:J,returnType:$(H)}}function V(G,q){let z=[],H="",J=0;for(let L=0;L<G.length;L++){let Q=G[L];if(Q==="<"||Q==="("||Q==="{"||Q==="[")J++,H+=Q;else if(Q===">"||Q===")"||Q==="}"||Q==="]")J--,H+=Q;else if(Q===q&&J===0)z.push(H.trim()),H="";else H+=Q}if(H.trim())z.push(H.trim());return z}function F(G){return V(G,",")}function O(G){let q=[],z="",H=0;for(let J=0;J<G.length;J++){let L=G[J];if(L==="<"||L==="("||L==="{"||L==="[")H++,z+=L;else if(L===">"||L===")"||L==="}"||L==="]")H--,z+=L;else if((L===";"||L===`
-`)&&H===0){if(z.trim())q.push(z.trim());z=""}else z+=L}if(z.trim())q.push(z.trim());return q}function B(G){let q=[],z=/interface\s+(\w+)(?:\s+extends\s+([\w,\s]+))?\s*\{/g,H;while((H=z.exec(G))!==null){let J=H[1],L=H[2],Q=H.index+H[0].length-1,U=1,W=Q+1;while(W<G.length&&U>0){if(G[W]==="{")U++;else if(G[W]==="}")U--;W++}let Y=G.slice(Q+1,W-1);q.push({name:J,body:Y,extends:L?L.split(",").map((Z)=>Z.trim()):void 0})}return q}function I(G){let q=[],z=[],H=[],J,L=/@types\s*([\s\S]*?)@endtypes/g,Q=G.matchAll(L);for(let U of Q){let W=U[1],Y=B(W);for(let X of Y){let E=k(`{${X.body}}`),j={name:X.name,properties:E.properties||{},extends:X.extends};if(q.push(j),X.name==="PageContext"||X.name==="TemplateContext"||X.name==="Context")J=j}let Z=/type\s+(\w+)\s*=\s*([^;]+);?/g,K=W.matchAll(Z);for(let X of K){let E=X[1],j=X[2].trim();z.push({name:E,type:$(j)})}}if(!J&&q.length>0)J=q[0];return{interfaces:q,typeAliases:z,contextType:J,errors:H}}function M(G,q){let z={interfaces:new Map,typeAliases:new Map,variables:new Map,errors:[],warnings:[]};for(let H of G.interfaces)z.interfaces.set(H.name,H);for(let H of G.typeAliases)z.typeAliases.set(H.name,H);if(G.contextType)for(let[H,J]of Object.entries(G.contextType.properties))z.variables.set(H,J.type);if(q&&z.variables.size===0)for(let[H,J]of Object.entries(q))z.variables.set(H,D(J));return z}function D(G){if(G===null)return{kind:"primitive",value:"null"};if(G===void 0)return{kind:"primitive",value:"undefined"};let q=typeof G;if(q==="string")return{kind:"primitive",value:"string"};if(q==="number")return{kind:"primitive",value:"number"};if(q==="boolean")return{kind:"primitive",value:"boolean"};if(q==="function")return{kind:"function",parameters:[],returnType:{kind:"primitive",value:"any"}};if(Array.isArray(G)){if(G.length===0)return{kind:"array",elementType:{kind:"primitive",value:"any"}};return{kind:"array",elementType:D(G[0])}}if(q==="object"){let z={};for(let[H,J]of Object.entries(G))z[H]={type:D(J),optional:!1,readonly:!1};return{kind:"object",properties:z}}return{kind:"primitive",value:"any"}}function R(G,q){let z=G.trim();if(/^\w+$/.test(z)){let H=q.variables.get(z);if(!H)return{message:`Unknown variable '${z}'`,expression:z};return H}if(z.includes(".")){let H=z.split("."),J=q.variables.get(H[0]);if(!J)return{message:`Unknown variable '${H[0]}'`,expression:z};for(let L=1;L<H.length;L++){let Q=H[L],U=Q.endsWith("?")?Q.slice(0,-1):Q;if(!J)return{message:`Cannot access property '${U}' on undefined type`,expression:z};if(J.kind==="object"&&J.properties){let W=J.properties[U];if(!W)return{message:`Property '${U}' does not exist on type`,expression:z};J=W.type}else if(J.kind==="reference"){let W=q.interfaces.get(J.value);if(W&&W.properties[U])J=W.properties[U].type;else return{message:`Property '${U}' does not exist on type '${J.value}'`,expression:z}}else if(J.kind==="array"&&U==="length")J={kind:"primitive",value:"number"};else return{message:`Cannot access property '${U}' on type`,expression:z}}return J??{kind:"primitive",value:"any"}}return{kind:"primitive",value:"any"}}function w(G,q){let z=[],H=/\{\{([^}]+)\}\}/g,J=G.matchAll(H);for(let L of J){let Q=L[1].trim();if(Q.includes("|"))continue;let U=R(Q,q);if("message"in U)z.push(U)}return z}function b(G,q){let z=["// Auto-generated by stx - DO NOT EDIT",`// Source: ${G}`,"",'declare module "*.stx" {'];for(let J of q.interfaces){z.push(`  export interface ${J.name} {`);for(let[L,Q]of Object.entries(J.properties)){let U=Q.optional?"?":"",W=Q.readonly?"readonly ":"";z.push(`    ${W}${L}${U}: ${_(Q.type)};`)}z.push("  }"),z.push("")}for(let J of q.typeAliases)z.push(`  export type ${J.name} = ${_(J.type)};`);if(q.contextType)z.push(""),z.push(`  export function render(context: ${q.contextType.name}): Promise<string>;`);else z.push(""),z.push("  export function render(context: Record<string, unknown>): Promise<string>;");z.push("}");let H=G.replace(/\.stx$/,".d.ts");return{content:z.join(`
-`),filename:H}}function _(G){switch(G.kind){case"primitive":return G.value||"any";case"array":return`Array<${_(G.elementType)}>`;case"object":{if(!G.properties||Object.keys(G.properties).length===0)return"{}";return`{ ${Object.entries(G.properties).map(([z,H])=>{let J=H.optional?"?":"";return`${H.readonly?"readonly ":""}${z}${J}: ${_(H.type)}`}).join("; ")} }`}case"union":return G.types.map((q)=>_(q)).join(" | ");case"intersection":return G.types.map((q)=>_(q)).join(" & ");case"literal":if(typeof G.literalValue==="string")return`'${G.literalValue}'`;return String(G.literalValue);case"function":return`(${(G.parameters||[]).map((z)=>{let H=z.optional?"?":"";return`${z.rest?"...":""}${z.name}${H}: ${_(z.type)}`}).join(", ")}) => ${_(G.returnType)}`;case"generic":return`${G.value}<${G.typeArguments.map((q)=>_(q)).join(", ")}>`;case"reference":return G.value||"unknown";default:return"unknown"}}function C(G){let q=I(G);return{template:G.replace(/@types\s*[\s\S]*?@endtypes/g,""),types:q}}function N(G,q){let{types:z}=C(G),H=M(z,q);return{errors:w(G,H),warnings:H.warnings}}export{w as validateTemplateTypes,_ as typeToString,R as typeCheckExpression,C as processTypesDirective,$ as parseTypeAnnotation,D as inferTypeFromValue,b as generateTypeDefinitions,I as extractTypesFromTemplate,M as createTypeContext,N as compileTimeTypeCheck};
+export function parseTypeAnnotation(typeStr) {
+  const trimmed = typeStr.trim();
+  if (["string", "number", "boolean", "null", "undefined", "any", "unknown", "never", "void"].includes(trimmed))
+    return { kind: "primitive", value: trimmed };
+  if (trimmed.endsWith("[]"))
+    return {
+      kind: "array",
+      elementType: parseTypeAnnotation(trimmed.slice(0, -2))
+    };
+  if (trimmed.startsWith("Array<") && trimmed.endsWith(">"))
+    return {
+      kind: "array",
+      elementType: parseTypeAnnotation(trimmed.slice(6, -1))
+    };
+  if (trimmed.includes("|") && !trimmed.startsWith("{") && !trimmed.startsWith("("))
+    return { kind: "union", types: splitByOperator(trimmed, "|").map((t) => parseTypeAnnotation(t)) };
+  if (trimmed.includes("&") && !trimmed.startsWith("{") && !trimmed.startsWith("("))
+    return { kind: "intersection", types: splitByOperator(trimmed, "&").map((t) => parseTypeAnnotation(t)) };
+  if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith('"') && trimmed.endsWith('"'))
+    return { kind: "literal", literalValue: trimmed.slice(1, -1) };
+  if (/^\d+$/.test(trimmed))
+    return { kind: "literal", literalValue: Number.parseInt(trimmed) };
+  if (trimmed === "true" || trimmed === "false")
+    return { kind: "literal", literalValue: trimmed === "true" };
+  if (trimmed.startsWith("{") && trimmed.endsWith("}"))
+    return parseObjectType(trimmed);
+  if (trimmed.includes("=>"))
+    return parseFunctionType(trimmed);
+  if (trimmed.includes("<") && trimmed.endsWith(">")) {
+    const baseEnd = trimmed.indexOf("<"), baseName = trimmed.slice(0, baseEnd), argsStr = trimmed.slice(baseEnd + 1, -1), typeArgs = splitByComma(argsStr).map((t) => parseTypeAnnotation(t));
+    return { kind: "generic", value: baseName, typeArguments: typeArgs };
+  }
+  return { kind: "reference", value: trimmed };
+}
+function parseObjectType(typeStr) {
+  const inner = typeStr.slice(1, -1).trim(), properties = {};
+  if (!inner)
+    return { kind: "object", properties };
+  const members = splitObjectMembers(inner);
+  for (const member of members) {
+    const trimmedMember = member.trim();
+    if (!trimmedMember)
+      continue;
+    const readonlyMatch = trimmedMember.startsWith("readonly "), withoutReadonly = readonlyMatch ? trimmedMember.slice(9) : trimmedMember, colonIndex = withoutReadonly.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    let propName = withoutReadonly.slice(0, colonIndex).trim();
+    const propType = withoutReadonly.slice(colonIndex + 1).trim(), optional = propName.endsWith("?");
+    if (optional)
+      propName = propName.slice(0, -1);
+    properties[propName] = {
+      type: parseTypeAnnotation(propType),
+      optional,
+      readonly: readonlyMatch
+    };
+  }
+  return { kind: "object", properties };
+}
+function parseFunctionType(typeStr) {
+  const arrowIndex = typeStr.indexOf("=>"), paramsStr = typeStr.slice(0, arrowIndex).trim(), returnStr = typeStr.slice(arrowIndex + 2).trim(), parameters = [];
+  if (paramsStr.startsWith("(") && paramsStr.endsWith(")")) {
+    const inner = paramsStr.slice(1, -1), params = splitByComma(inner);
+    for (const param of params) {
+      const trimmed = param.trim();
+      if (!trimmed)
+        continue;
+      const rest = trimmed.startsWith("..."), withoutRest = rest ? trimmed.slice(3) : trimmed, colonIndex = withoutRest.indexOf(":");
+      if (colonIndex === -1)
+        parameters.push({
+          name: withoutRest,
+          type: { kind: "primitive", value: "any" },
+          optional: !1,
+          rest
+        });
+      else {
+        let name = withoutRest.slice(0, colonIndex).trim();
+        const type = withoutRest.slice(colonIndex + 1).trim(), optional = name.endsWith("?");
+        if (optional)
+          name = name.slice(0, -1);
+        parameters.push({
+          name,
+          type: parseTypeAnnotation(type),
+          optional,
+          rest
+        });
+      }
+    }
+  }
+  return {
+    kind: "function",
+    parameters,
+    returnType: parseTypeAnnotation(returnStr)
+  };
+}
+function splitByOperator(str, operator) {
+  const results = [];
+  let current = "", depth = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str[i];
+    if (char === "<" || char === "(" || char === "{" || char === "[") {
+      depth++;
+      current += char;
+    } else if (char === ">" || char === ")" || char === "}" || char === "]") {
+      depth--;
+      current += char;
+    } else if (char === operator && depth === 0) {
+      results.push(current.trim());
+      current = "";
+    } else
+      current += char;
+  }
+  if (current.trim())
+    results.push(current.trim());
+  return results;
+}
+function splitByComma(str) {
+  return splitByOperator(str, ",");
+}
+function splitObjectMembers(str) {
+  const results = [];
+  let current = "", depth = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str[i];
+    if (char === "<" || char === "(" || char === "{" || char === "[") {
+      depth++;
+      current += char;
+    } else if (char === ">" || char === ")" || char === "}" || char === "]") {
+      depth--;
+      current += char;
+    } else if ((char === ";" || char === `
+`) && depth === 0) {
+      if (current.trim())
+        results.push(current.trim());
+      current = "";
+    } else
+      current += char;
+  }
+  if (current.trim())
+    results.push(current.trim());
+  return results;
+}
+function parseInterfaceDeclarations(content) {
+  const results = [], interfaceKeyword = /interface\s+(\w+)(?:\s+extends\s+([\w,\s]+))?\s*\{/g;
+  let match;
+  while ((match = interfaceKeyword.exec(content)) !== null) {
+    const name = match[1], extendsClause = match[2], startBrace = match.index + match[0].length - 1;
+    let depth = 1, pos = startBrace + 1;
+    while (pos < content.length && depth > 0) {
+      if (content[pos] === "{")
+        depth++;
+      else if (content[pos] === "}")
+        depth--;
+      pos++;
+    }
+    const body = content.slice(startBrace + 1, pos - 1);
+    results.push({
+      name,
+      body,
+      extends: extendsClause ? extendsClause.split(",").map((s) => s.trim()) : void 0
+    });
+  }
+  return results;
+}
+export function extractTypesFromTemplate(template) {
+  const interfaces = [], typeAliases = [], errors = [];
+  let contextType;
+  const typesBlockRegex = /@types\s*([\s\S]*?)@endtypes/g, typesBlocks = template.matchAll(typesBlockRegex);
+  for (const match of typesBlocks) {
+    const content = match[1], interfaceParsed = parseInterfaceDeclarations(content);
+    for (const parsed of interfaceParsed) {
+      const parsedType = parseObjectType(`{${parsed.body}}`), iface = {
+        name: parsed.name,
+        properties: parsedType.properties || {},
+        extends: parsed.extends
+      };
+      interfaces.push(iface);
+      if (parsed.name === "PageContext" || parsed.name === "TemplateContext" || parsed.name === "Context")
+        contextType = iface;
+    }
+    const typeAliasRegex = /type\s+(\w+)\s*=\s*([^;]+);?/g, typeAliasMatches = content.matchAll(typeAliasRegex);
+    for (const typeMatch of typeAliasMatches) {
+      const name = typeMatch[1], typeStr = typeMatch[2].trim();
+      typeAliases.push({
+        name,
+        type: parseTypeAnnotation(typeStr)
+      });
+    }
+  }
+  if (!contextType && interfaces.length > 0)
+    contextType = interfaces[0];
+  return { interfaces, typeAliases, contextType, errors };
+}
+export function createTypeContext(extracted, runtimeContext) {
+  const ctx = {
+    interfaces: new Map,
+    typeAliases: new Map,
+    variables: new Map,
+    errors: [],
+    warnings: []
+  };
+  for (const iface of extracted.interfaces)
+    ctx.interfaces.set(iface.name, iface);
+  for (const alias of extracted.typeAliases)
+    ctx.typeAliases.set(alias.name, alias);
+  if (extracted.contextType)
+    for (const [name, prop] of Object.entries(extracted.contextType.properties))
+      ctx.variables.set(name, prop.type);
+  if (runtimeContext && ctx.variables.size === 0)
+    for (const [name, value] of Object.entries(runtimeContext))
+      ctx.variables.set(name, inferTypeFromValue(value));
+  return ctx;
+}
+export function inferTypeFromValue(value) {
+  if (value === null)
+    return { kind: "primitive", value: "null" };
+  if (value === void 0)
+    return { kind: "primitive", value: "undefined" };
+  const type = typeof value;
+  if (type === "string")
+    return { kind: "primitive", value: "string" };
+  if (type === "number")
+    return { kind: "primitive", value: "number" };
+  if (type === "boolean")
+    return { kind: "primitive", value: "boolean" };
+  if (type === "function")
+    return { kind: "function", parameters: [], returnType: { kind: "primitive", value: "any" } };
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return { kind: "array", elementType: { kind: "primitive", value: "any" } };
+    return { kind: "array", elementType: inferTypeFromValue(value[0]) };
+  }
+  if (type === "object") {
+    const properties = {};
+    for (const [key, val] of Object.entries(value))
+      properties[key] = {
+        type: inferTypeFromValue(val),
+        optional: !1,
+        readonly: !1
+      };
+    return { kind: "object", properties };
+  }
+  return { kind: "primitive", value: "any" };
+}
+export function typeCheckExpression(expression, context) {
+  const trimmed = expression.trim();
+  if (/^\w+$/.test(trimmed)) {
+    const varType = context.variables.get(trimmed);
+    if (!varType)
+      return {
+        message: `Unknown variable '${trimmed}'`,
+        expression: trimmed
+      };
+    return varType;
+  }
+  if (trimmed.includes(".")) {
+    const parts = trimmed.split(".");
+    let currentType = context.variables.get(parts[0]);
+    if (!currentType)
+      return {
+        message: `Unknown variable '${parts[0]}'`,
+        expression: trimmed
+      };
+    for (let i = 1;i < parts.length; i++) {
+      const prop = parts[i], propName = prop.endsWith("?") ? prop.slice(0, -1) : prop;
+      if (!currentType)
+        return {
+          message: `Cannot access property '${propName}' on undefined type`,
+          expression: trimmed
+        };
+      if (currentType.kind === "object" && currentType.properties) {
+        const propDef = currentType.properties[propName];
+        if (!propDef)
+          return {
+            message: `Property '${propName}' does not exist on type`,
+            expression: trimmed
+          };
+        currentType = propDef.type;
+      } else if (currentType.kind === "reference") {
+        const iface = context.interfaces.get(currentType.value);
+        if (iface && iface.properties[propName])
+          currentType = iface.properties[propName].type;
+        else
+          return {
+            message: `Property '${propName}' does not exist on type '${currentType.value}'`,
+            expression: trimmed
+          };
+      } else if (currentType.kind === "array" && propName === "length")
+        currentType = { kind: "primitive", value: "number" };
+      else
+        return {
+          message: `Cannot access property '${propName}' on type`,
+          expression: trimmed
+        };
+    }
+    return currentType ?? { kind: "primitive", value: "any" };
+  }
+  return { kind: "primitive", value: "any" };
+}
+export function validateTemplateTypes(template, context) {
+  const errors = [], exprRegex = /\{\{([^}]+)\}\}/g, matches = template.matchAll(exprRegex);
+  for (const match of matches) {
+    const expression = match[1].trim();
+    if (expression.includes("|"))
+      continue;
+    const result = typeCheckExpression(expression, context);
+    if ("message" in result)
+      errors.push(result);
+  }
+  return errors;
+}
+export function generateTypeDefinitions(templatePath, extracted) {
+  const lines = [
+    "// Auto-generated by stx - DO NOT EDIT",
+    `// Source: ${templatePath}`,
+    "",
+    'declare module "*.stx" {'
+  ];
+  for (const iface of extracted.interfaces) {
+    lines.push(`  export interface ${iface.name} {`);
+    for (const [propName, prop] of Object.entries(iface.properties)) {
+      const optional = prop.optional ? "?" : "", readonly = prop.readonly ? "readonly " : "";
+      lines.push(`    ${readonly}${propName}${optional}: ${typeToString(prop.type)};`);
+    }
+    lines.push("  }");
+    lines.push("");
+  }
+  for (const alias of extracted.typeAliases)
+    lines.push(`  export type ${alias.name} = ${typeToString(alias.type)};`);
+  if (extracted.contextType) {
+    lines.push("");
+    lines.push(`  export function render(context: ${extracted.contextType.name}): Promise<string>;`);
+  } else {
+    lines.push("");
+    lines.push("  export function render(context: Record<string, unknown>): Promise<string>;");
+  }
+  lines.push("}");
+  const filename = templatePath.replace(/\.stx$/, ".d.ts");
+  return {
+    content: lines.join(`
+`),
+    filename
+  };
+}
+export function typeToString(type) {
+  switch (type.kind) {
+    case "primitive":
+      return type.value || "any";
+    case "array":
+      return `Array<${typeToString(type.elementType)}>`;
+    case "object": {
+      if (!type.properties || Object.keys(type.properties).length === 0)
+        return "{}";
+      return `{ ${Object.entries(type.properties).map(([name, prop]) => {
+        const opt = prop.optional ? "?" : "";
+        return `${prop.readonly ? "readonly " : ""}${name}${opt}: ${typeToString(prop.type)}`;
+      }).join("; ")} }`;
+    }
+    case "union":
+      return type.types.map((t) => typeToString(t)).join(" | ");
+    case "intersection":
+      return type.types.map((t) => typeToString(t)).join(" & ");
+    case "literal":
+      if (typeof type.literalValue === "string")
+        return `'${type.literalValue}'`;
+      return String(type.literalValue);
+    case "function":
+      return `(${(type.parameters || []).map((p) => {
+        const opt = p.optional ? "?" : "";
+        return `${p.rest ? "..." : ""}${p.name}${opt}: ${typeToString(p.type)}`;
+      }).join(", ")}) => ${typeToString(type.returnType)}`;
+    case "generic":
+      return `${type.value}<${type.typeArguments.map((t) => typeToString(t)).join(", ")}>`;
+    case "reference":
+      return type.value || "unknown";
+    default:
+      return "unknown";
+  }
+}
+export function processTypesDirective(template) {
+  const types = extractTypesFromTemplate(template);
+  return { template: template.replace(/@types\s*[\s\S]*?@endtypes/g, ""), types };
+}
+export function compileTimeTypeCheck(template, runtimeContext) {
+  const { types } = processTypesDirective(template), context = createTypeContext(types, runtimeContext);
+  return { errors: validateTemplateTypes(template, context), warnings: context.warnings };
+}