tjs-lang 0.7.3 → 0.7.4

package/dist/tjs-transpiler.js

@@ -1,3 +0,0 @@
-import{parseExpressionAt as U}from"acorn";class A extends Error{line;column;source;filename;constructor(S,J,O,D){let T=`${D||"<source>"}:${J.line}:${J.column}`;super(`${S} at ${T}`);this.name="TranspileError",this.line=J.line,this.column=J.column,this.source=O,this.filename=D}}function B(S){if(S.loc)return{line:S.loc.start.line,column:S.loc.start.column};return{line:1,column:0}}function w(S){switch(S.type){case"Literal":{let J=S.value;if(J===null)return{kind:"null"};if(typeof J==="string")return{kind:"string"};if(typeof J==="number"){let O=S.raw;if(O&&O.includes("."))return{kind:"number"};return{kind:"integer"}}if(typeof J==="boolean")return{kind:"boolean"};return{kind:"any"}}case"ArrayExpression":{let J=S.elements;if(J.length===0)return{kind:"array",items:{kind:"any"}};let O=J.filter((j)=>j!=null).map((j)=>w(j));if(O.length===0)return{kind:"array",items:{kind:"any"}};let D=new Map;for(let j of O){let I=JSON.stringify(j);if(!D.has(I))D.set(I,j)}let T=[...D.values()];return{kind:"array",items:T.length===1?T[0]:{kind:"union",members:T}}}case"ObjectExpression":{let J=S.properties,O={};for(let D of J)if(D.type==="Property"&&D.key.type==="Identifier"){let T=D.key.name;O[T]=w(D.value)}return{kind:"object",shape:O}}case"LogicalExpression":{let{operator:J,left:O,right:D}=S;if(J==="||")return w(O);if(J==="&&")return w(D);if(J==="??")return w(D);return{kind:"any"}}case"BinaryExpression":{let{operator:J,left:O,right:D}=S;if(J==="|"){let T=w(O),R=w(D);if(R.kind==="null")return{...T,nullable:!0};if(T.kind==="null")return{...R,nullable:!0};return{kind:"union",members:[T,R]}}return{kind:"any"}}case"Identifier":{if(S.name==="undefined")return{kind:"undefined"};return{kind:"any"}}case"UnaryExpression":{let{operator:J,argument:O}=S;if(J==="+"&&O.type==="Literal"){if(typeof O.value==="number")return{kind:"non-negative-integer"}}if(J==="-"&&O.type==="Literal"){if(typeof O.value==="number"){let T=O.raw;if(T&&T.includes("."))return{kind:"number"};return{kind:"integer"}}}return{kind:"any"}}default:return{kind:"any"}}}function W(S,J){if(S.type==="Identifier")return{name:S.name,type:{kind:"any"},required:!0};if(S.type==="AssignmentPattern"){let{left:O,right:D}=S;if(O.type!=="Identifier")throw new A("Only simple parameter names are supported",B(S));let T=O.name,R=J?.has(T)??!1,j=w(D),I=M(D);return{name:T,type:j,required:R,default:R?null:I,example:I,loc:{start:S.start,end:S.end}}}if(S.type==="ObjectPattern"){let O=S.properties,D={},T={};for(let R of O)if(R.type==="Property"){let j=R.key.type==="Identifier"?R.key.name:String(R.key.value);if(R.value.type==="Identifier")D[j]={kind:"any"},T[j]={name:j,type:{kind:"any"},required:!0};else if(R.value.type==="AssignmentPattern"){let I=W(R.value,J),N=J?.has(j)??!1;D[j]=I.type,T[j]={name:j,type:I.type,required:N,default:N?null:I.example,example:I.example}}}return{name:"__destructured__",type:{kind:"object",shape:D,destructuredParams:T},required:!0}}throw new A(`Unsupported parameter pattern: ${S.type}`,B(S))}function M(S){switch(S.type){case"Literal":return S.value;case"ArrayExpression":return S.elements.map((J)=>J?M(J):null);case"ObjectExpression":{let J={};for(let O of S.properties)if(O.type==="Property"&&O.key.type==="Identifier")J[O.key.name]=M(O.value);return J}case"UnaryExpression":if(S.operator==="-"){let J=M(S.argument);return typeof J==="number"?-J:void 0}if(S.operator==="+"){let J=M(S.argument);return typeof J==="number"?+J:void 0}return;case"BinaryExpression":{let{operator:J,left:O}=S;if(J==="|")return M(O);return}case"LogicalExpression":{let{operator:J,left:O,right:D}=S;if(J==="&&"){if(O.type==="Literal"&&O.value===null)return null}if(J==="||")return M(O)??M(D);if(J==="??")return M(O)??M(D);return}default:return}}function G(S){try{let J=U(S,0,{ecmaVersion:2022});return w(J)}catch{return{kind:"any"}}}function C(S){switch(S.kind){case"string":return S.nullable?"string | null":"string";case"number":return S.nullable?"number | null":"number";case"integer":return S.nullable?"integer | null":"integer";case"non-negative-integer":return S.nullable?"non-negative integer | null":"non-negative integer";case"boolean":return S.nullable?"boolean | null":"boolean";case"null":return"null";case"any":return"any";case"array":{let J=S.items?C(S.items):"any";return S.nullable?`${J}[] | null`:`${J}[]`}case"object":{if(!S.shape||Object.keys(S.shape).length===0)return S.nullable?"object | null":"object";let J=Object.entries(S.shape).map(([O,D])=>`${O}: ${C(D)}`).join(", ");return S.nullable?`{ ${J} } | null`:`{ ${J} }`}case"union":return S.members?.map(C).join(" | ")||"any";default:return"any"}}export{SS as wrap,e as validateArgs,C as typeToString,p as typeOf,L as transpileToJS,X as transpile,P as transformFunction,Z as tjs,u as testUtils,o as runtime,h as preprocess,G as parseReturnType,W as parseParameter,F as parse,v as lint,t as isError,n as installRuntime,w as inferTypeFromValue,b as getToolDefinitions,i as extractTests,x as extractTDoc,M as extractLiteralValue,y as expectFunction,r as error,JS as emitRuntimeWrapper,$ as createAgent,a as checkType,d as assertFunction,Y as ajs,OS as TJS_VERSION,s as Schema};
-
-//# debugId=2A75523C6E6B080464756E2164756E21

package/dist/tjs-transpiler.js.map

@@ -1,11 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/lang/inference.ts", "../src/lang/types.ts"],
-  "sourcesContent": [
-    "/**\n * Type inference from value patterns\n *\n * Extracts types from example values:\n *   'string' -> { kind: 'string' }\n *   10 -> { kind: 'number' }\n *   ['string'] -> { kind: 'array', items: { kind: 'string' } }\n *   { name: 'string' } -> { kind: 'object', shape: { name: { kind: 'string' } } }\n *   'string' | null -> { kind: 'string', nullable: true }\n *   'string' | 0 -> { kind: 'union', members: [{ kind: 'string' }, { kind: 'number' }] }\n */\n\nimport { parseExpressionAt } from 'acorn'\nimport type { Expression, Pattern } from 'acorn'\nimport type { TypeDescriptor, ParameterDescriptor } from './types'\nimport { getLocation, TranspileError } from './types'\n\n/**\n * Infer type from a value expression (example value)\n */\nexport function inferTypeFromValue(node: Expression): TypeDescriptor {\n  switch (node.type) {\n    case 'Literal': {\n      const value = (node as any).value\n      if (value === null) {\n        return { kind: 'null' }\n      }\n      if (typeof value === 'string') {\n        return { kind: 'string' }\n      }\n      if (typeof value === 'number') {\n        // Distinguish float vs integer by checking if source contains '.'\n        // 2.0 -> number (float), 42 -> integer\n        const raw = (node as any).raw as string | undefined\n        if (raw && raw.includes('.')) {\n          return { kind: 'number' }\n        }\n        return { kind: 'integer' }\n      }\n      if (typeof value === 'boolean') {\n        return { kind: 'boolean' }\n      }\n      return { kind: 'any' }\n    }\n\n    case 'ArrayExpression': {\n      const elements = (node as any).elements as Expression[]\n      if (elements.length === 0) {\n        return { kind: 'array', items: { kind: 'any' } }\n      }\n      // Infer type from all elements — if homogeneous, use that type;\n      // if heterogeneous, produce a union of distinct kinds\n      const itemTypes = elements\n        .filter((el) => el != null)\n        .map((el) => inferTypeFromValue(el))\n      if (itemTypes.length === 0) {\n        return { kind: 'array', items: { kind: 'any' } }\n      }\n      // Deduplicate by structure\n      const seen = new Map<string, TypeDescriptor>()\n      for (const t of itemTypes) {\n        const key = JSON.stringify(t)\n        if (!seen.has(key)) seen.set(key, t)\n      }\n      const unique = [...seen.values()]\n      const items =\n        unique.length === 1\n          ? unique[0]\n          : { kind: 'union' as const, members: unique }\n      return { kind: 'array', items }\n    }\n\n    case 'ObjectExpression': {\n      const properties = (node as any).properties as any[]\n      const shape: Record<string, TypeDescriptor> = {}\n\n      for (const prop of properties) {\n        if (prop.type === 'Property' && prop.key.type === 'Identifier') {\n          const key = prop.key.name\n          shape[key] = inferTypeFromValue(prop.value)\n        }\n      }\n\n      return { kind: 'object', shape }\n    }\n\n    case 'LogicalExpression': {\n      const { operator, left, right } = node as any\n\n      if (operator === '||') {\n        // || is JavaScript logical OR — infer type from left operand\n        return inferTypeFromValue(left)\n      }\n\n      if (operator === '&&') {\n        // null && type means required type (null is just a marker)\n        const rightType = inferTypeFromValue(right)\n        return rightType\n      }\n\n      if (operator === '??') {\n        // Nullish coalescing: left ?? right - type is the right side (fallback)\n        const rightType = inferTypeFromValue(right)\n        return rightType\n      }\n\n      return { kind: 'any' }\n    }\n\n    case 'BinaryExpression': {\n      const { operator, left, right } = node as any\n      // | means union type (e.g., 0 | null, '' | undefined)\n      if (operator === '|') {\n        const leftType = inferTypeFromValue(left)\n        const rightType = inferTypeFromValue(right)\n\n        if (rightType.kind === 'null') {\n          return { ...leftType, nullable: true }\n        }\n        if (leftType.kind === 'null') {\n          return { ...rightType, nullable: true }\n        }\n        return {\n          kind: 'union',\n          members: [leftType, rightType],\n        }\n      }\n      return { kind: 'any' }\n    }\n\n    case 'Identifier': {\n      // Handle undefined as a type\n      if ((node as any).name === 'undefined') {\n        return { kind: 'undefined' }\n      }\n      // Other identifiers in type position aren't valid example types\n      return { kind: 'any' }\n    }\n\n    case 'UnaryExpression': {\n      const op = (node as any).operator\n      const arg = (node as any).argument\n\n      // +N means non-negative integer (e.g., +1, +3)\n      if (op === '+' && arg.type === 'Literal') {\n        const value = arg.value\n        if (typeof value === 'number') {\n          return { kind: 'non-negative-integer' }\n        }\n      }\n\n      // -N means integer or float depending on source\n      if (op === '-' && arg.type === 'Literal') {\n        const value = arg.value\n        if (typeof value === 'number') {\n          const raw = arg.raw as string | undefined\n          if (raw && raw.includes('.')) {\n            return { kind: 'number' }\n          }\n          return { kind: 'integer' }\n        }\n      }\n      return { kind: 'any' }\n    }\n\n    default:\n      return { kind: 'any' }\n  }\n}\n\n/**\n * Parse a parameter and extract its type and default value\n *\n * @param param - The AST node for the parameter\n * @param requiredParams - Optional set of parameter names that are required (from colon syntax)\n */\nexport function parseParameter(\n  param: Pattern,\n  requiredParams?: Set<string>\n): ParameterDescriptor {\n  // Simple identifier: function foo(x) - required, any type\n  if (param.type === 'Identifier') {\n    return {\n      name: (param as any).name,\n      type: { kind: 'any' },\n      required: true,\n    }\n  }\n\n  // Assignment pattern: function foo(x = value)\n  if (param.type === 'AssignmentPattern') {\n    const { left, right } = param as any\n\n    if (left.type !== 'Identifier') {\n      throw new TranspileError(\n        'Only simple parameter names are supported',\n        getLocation(param)\n      )\n    }\n\n    const name = left.name\n\n    // Check if this parameter was marked as required via colon syntax\n    const isRequired = requiredParams?.has(name) ?? false\n\n    // Infer type from the example value\n    const type = inferTypeFromValue(right)\n    const exampleValue = extractLiteralValue(right)\n\n    return {\n      name,\n      type,\n      required: isRequired,\n      default: isRequired ? null : exampleValue,\n      example: exampleValue,\n      loc: { start: param.start, end: param.end },\n    }\n  }\n\n  // Destructuring pattern: function foo({ a, b })\n  if (param.type === 'ObjectPattern') {\n    // For destructuring, we create a synthetic \"args\" parameter\n    // The individual properties become fields with their own defaults\n    const properties = (param as any).properties as any[]\n    const shape: Record<string, TypeDescriptor> = {}\n    // Store full parameter descriptors for destructured properties\n    const destructuredParams: Record<string, ParameterDescriptor> = {}\n\n    for (const prop of properties) {\n      if (prop.type === 'Property') {\n        const key =\n          prop.key.type === 'Identifier'\n            ? prop.key.name\n            : String(prop.key.value)\n\n        if (prop.value.type === 'Identifier') {\n          // { name } - required, any type\n          shape[key] = { kind: 'any' }\n          destructuredParams[key] = {\n            name: key,\n            type: { kind: 'any' },\n            required: true,\n          }\n        } else if (prop.value.type === 'AssignmentPattern') {\n          // { name = default } - check requiredParams to see if this was originally colon syntax\n          const innerParam = parseParameter(prop.value, requiredParams)\n          const isRequired = requiredParams?.has(key) ?? false\n          shape[key] = innerParam.type\n          destructuredParams[key] = {\n            name: key,\n            type: innerParam.type,\n            required: isRequired,\n            default: isRequired ? null : innerParam.example,\n            example: innerParam.example,\n          }\n        }\n      }\n    }\n\n    return {\n      name: '__destructured__',\n      type: { kind: 'object', shape, destructuredParams },\n      required: true,\n    }\n  }\n\n  throw new TranspileError(\n    `Unsupported parameter pattern: ${param.type}`,\n    getLocation(param)\n  )\n}\n\n/**\n * Extract a literal value from an expression for default values\n */\nexport function extractLiteralValue(node: Expression): any {\n  switch (node.type) {\n    case 'Literal':\n      return (node as any).value\n\n    case 'ArrayExpression':\n      return (node as any).elements.map((el: Expression) =>\n        el ? extractLiteralValue(el) : null\n      )\n\n    case 'ObjectExpression': {\n      const result: Record<string, any> = {}\n      for (const prop of (node as any).properties) {\n        if (prop.type === 'Property' && prop.key.type === 'Identifier') {\n          result[prop.key.name] = extractLiteralValue(prop.value)\n        }\n      }\n      return result\n    }\n\n    case 'UnaryExpression':\n      if ((node as any).operator === '-') {\n        const arg = extractLiteralValue((node as any).argument)\n        return typeof arg === 'number' ? -arg : undefined\n      }\n      if ((node as any).operator === '+') {\n        const arg = extractLiteralValue((node as any).argument)\n        return typeof arg === 'number' ? +arg : undefined\n      }\n      return undefined\n\n    case 'BinaryExpression': {\n      const { operator, left } = node as any\n      // | is union type — extract the left (primary) example value\n      if (operator === '|') {\n        return extractLiteralValue(left)\n      }\n      return undefined\n    }\n\n    case 'LogicalExpression': {\n      const { operator, left, right } = node as any\n      if (operator === '&&') {\n        // null && type evaluates to null (falsy short-circuit)\n        if (left.type === 'Literal' && left.value === null) {\n          return null\n        }\n      }\n      if (operator === '||') {\n        // value || fallback - return left if truthy\n        const leftVal = extractLiteralValue(left)\n        return leftVal ?? extractLiteralValue(right)\n      }\n      if (operator === '??') {\n        // value ?? fallback - return left if not null/undefined\n        const leftVal = extractLiteralValue(left)\n        return leftVal ?? extractLiteralValue(right)\n      }\n      return undefined\n    }\n\n    default:\n      return undefined\n  }\n}\n\n/**\n * Parse return type from a type annotation expression\n */\nexport function parseReturnType(typeExpr: string): TypeDescriptor {\n  // Simple approach: parse as expression and infer type\n  try {\n    const ast = parseExpressionAt(typeExpr, 0, {\n      ecmaVersion: 2022,\n    })\n    return inferTypeFromValue(ast)\n  } catch {\n    return { kind: 'any' }\n  }\n}\n\n/**\n * Convert TypeDescriptor to a human-readable string\n */\nexport function typeToString(type: TypeDescriptor): string {\n  switch (type.kind) {\n    case 'string':\n      return type.nullable ? 'string | null' : 'string'\n    case 'number':\n      return type.nullable ? 'number | null' : 'number'\n    case 'integer':\n      return type.nullable ? 'integer | null' : 'integer'\n    case 'non-negative-integer':\n      return type.nullable\n        ? 'non-negative integer | null'\n        : 'non-negative integer'\n    case 'boolean':\n      return type.nullable ? 'boolean | null' : 'boolean'\n    case 'null':\n      return 'null'\n    case 'any':\n      return 'any'\n    case 'array': {\n      const items = type.items ? typeToString(type.items) : 'any'\n      return type.nullable ? `${items}[] | null` : `${items}[]`\n    }\n    case 'object': {\n      if (!type.shape || Object.keys(type.shape).length === 0) {\n        return type.nullable ? 'object | null' : 'object'\n      }\n      const props = Object.entries(type.shape)\n        .map(([k, v]) => `${k}: ${typeToString(v)}`)\n        .join(', ')\n      return type.nullable ? `{ ${props} } | null` : `{ ${props} }`\n    }\n    case 'union':\n      return type.members?.map(typeToString).join(' | ') || 'any'\n    default:\n      return 'any'\n  }\n}\n\n/**\n * Check if a value matches a type descriptor\n */\nexport function checkType(value: any, type: TypeDescriptor): boolean {\n  // Handle null\n  if (value === null || value === undefined) {\n    return type.nullable || type.kind === 'null' || type.kind === 'any'\n  }\n\n  switch (type.kind) {\n    case 'any':\n      return true\n    case 'null':\n      return value === null\n    case 'string':\n      return typeof value === 'string'\n    case 'number':\n      return typeof value === 'number'\n    case 'integer':\n      return typeof value === 'number' && Number.isInteger(value)\n    case 'non-negative-integer':\n      return typeof value === 'number' && Number.isInteger(value) && value >= 0\n    case 'boolean':\n      return typeof value === 'boolean'\n    case 'array':\n      if (!Array.isArray(value)) return false\n      if (!type.items) return true\n      return value.every((item) => checkType(item, type.items!))\n    case 'object':\n      if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n        return false\n      }\n      if (!type.shape) return true\n      // Check that all required shape properties exist and match\n      for (const [key, propType] of Object.entries(type.shape)) {\n        if (!checkType(value[key], propType)) {\n          return false\n        }\n      }\n      return true\n    case 'union':\n      if (!type.members) return true\n      return type.members.some((member) => checkType(value, member))\n    default:\n      return true\n  }\n}\n",
-    "/**\n * Type definitions for the Agent99 JavaScript transpiler\n */\n\nimport type { Node } from 'acorn'\nimport type { SeqNode } from '../builder'\n\n// ============================================================================\n// Type System Types\n// ============================================================================\n\n/** Represents a type extracted from value patterns */\nexport interface TypeDescriptor {\n  kind:\n    | 'string'\n    | 'number'\n    | 'integer'\n    | 'non-negative-integer'\n    | 'boolean'\n    | 'null'\n    | 'undefined'\n    | 'array'\n    | 'object'\n    | 'union'\n    | 'any'\n  nullable?: boolean\n  /** For arrays: the element type */\n  items?: TypeDescriptor\n  /** For objects: the shape */\n  shape?: Record<string, TypeDescriptor>\n  /** For unions: the member types */\n  members?: TypeDescriptor[]\n  /** For destructured parameters: full parameter descriptors */\n  destructuredParams?: Record<string, ParameterDescriptor>\n}\n\n/** Describes a function parameter */\nexport interface ParameterDescriptor {\n  name: string\n  type: TypeDescriptor\n  required: boolean\n  default?: any\n  /** The example value used to infer the type (for autocomplete) */\n  example?: any\n  description?: string\n  /** Source location for error reporting */\n  loc?: { start: number; end: number }\n}\n\n/** Describes a function's complete signature */\nexport interface FunctionSignature {\n  name: string\n  description?: string\n  parameters: Record<string, ParameterDescriptor>\n  returns?: TypeDescriptor\n}\n\n// ============================================================================\n// Transpiler Options and Results\n// ============================================================================\n\n/** Options for the transpile function */\nexport interface TranspileOptions {\n  /** Include source locations in output AST */\n  sourceMaps?: boolean\n  /** Atom registry for validation (optional) */\n  atoms?: Record<string, { op: string }>\n  /** Filename for error messages */\n  filename?: string\n  /** Whether to use strict type checking */\n  strict?: boolean\n}\n\n/** Result of transpilation */\nexport interface TranspileResult {\n  /** The Agent99 AST */\n  ast: SeqNode\n  /** The function signature with types */\n  signature: FunctionSignature\n  /** Source map (if enabled) */\n  sourceMap?: SourceMap\n  /** Warnings (non-fatal issues) */\n  warnings: TranspileWarning[]\n}\n\n/** A non-fatal warning during transpilation */\nexport interface TranspileWarning {\n  message: string\n  line: number\n  column: number\n  source?: string\n}\n\n/** Source map for debugging */\nexport interface SourceMap {\n  version: 3\n  file: string\n  sources: string[]\n  mappings: string\n}\n\n// ============================================================================\n// Error Types\n// ============================================================================\n\n/** Base class for transpiler errors with source location */\nexport class TranspileError extends Error {\n  line: number\n  column: number\n  source?: string\n  filename?: string\n\n  constructor(\n    message: string,\n    location: { line: number; column: number },\n    source?: string,\n    filename?: string\n  ) {\n    const loc = `${filename || '<source>'}:${location.line}:${location.column}`\n    super(`${message} at ${loc}`)\n    this.name = 'TranspileError'\n    this.line = location.line\n    this.column = location.column\n    this.source = source\n    this.filename = filename\n  }\n}\n\n/** Syntax error during parsing */\nexport class SyntaxError extends TranspileError {\n  constructor(\n    message: string,\n    location: { line: number; column: number },\n    source?: string,\n    filename?: string\n  ) {\n    super(message, location, source, filename)\n    this.name = 'SyntaxError'\n  }\n\n  /**\n   * Format the error with source context for better debugging\n   * Shows the problematic line with a caret pointing to the error location\n   */\n  formatWithContext(contextLines = 2): string {\n    if (!this.source) return this.message\n\n    const lines = this.source.split('\\n')\n    const errorLine = this.line - 1 // 0-indexed\n    const startLine = Math.max(0, errorLine - contextLines)\n    const endLine = Math.min(lines.length - 1, errorLine + contextLines)\n\n    const output: string[] = []\n    const lineNumWidth = String(endLine + 1).length\n\n    // Add context before\n    for (let i = startLine; i <= endLine; i++) {\n      const lineNum = String(i + 1).padStart(lineNumWidth)\n      const marker = i === errorLine ? '>' : ' '\n      output.push(`${marker} ${lineNum} | ${lines[i]}`)\n\n      // Add caret pointing to error column\n      if (i === errorLine) {\n        const caretPadding = ' '.repeat(lineNumWidth + 4 + this.column)\n        output.push(`${caretPadding}^ ${this.message.split(' at ')[0]}`)\n      }\n    }\n\n    return output.join('\\n')\n  }\n}\n\n/** Type error during transpilation or runtime */\nexport class TypeError extends TranspileError {\n  expected?: string\n  received?: string\n  suggestion?: string\n\n  constructor(\n    message: string,\n    location: { line: number; column: number },\n    options?: {\n      expected?: string\n      received?: string\n      suggestion?: string\n      source?: string\n      filename?: string\n    }\n  ) {\n    super(message, location, options?.source, options?.filename)\n    this.name = 'TypeError'\n    this.expected = options?.expected\n    this.received = options?.received\n    this.suggestion = options?.suggestion\n  }\n}\n\n// ============================================================================\n// Transform Context\n// ============================================================================\n\n/** Context passed through the transformer */\nexport interface TransformContext {\n  /** Current scope depth */\n  depth: number\n  /** Variables declared in current scope with their types */\n  locals: Map<string, TypeDescriptor>\n  /** Parent scope's context (for scope chain) */\n  parent?: TransformContext\n  /** Function parameters */\n  parameters: Map<string, ParameterDescriptor>\n  /** Registered atom names */\n  atoms: Set<string>\n  /** Accumulated warnings */\n  warnings: TranspileWarning[]\n  /** Source code for error messages */\n  source: string\n  /** Filename */\n  filename: string\n  /** Options */\n  options: TranspileOptions\n}\n\n/** Create a child context for nested scopes */\nexport function createChildContext(parent: TransformContext): TransformContext {\n  return {\n    depth: parent.depth + 1,\n    locals: new Map(),\n    parent,\n    parameters: parent.parameters,\n    atoms: parent.atoms,\n    warnings: parent.warnings,\n    source: parent.source,\n    filename: parent.filename,\n    options: parent.options,\n  }\n}\n\n/** Look up a variable in the scope chain */\nexport function lookupVariable(\n  name: string,\n  ctx: TransformContext\n): TypeDescriptor | undefined {\n  // Check locals first\n  if (ctx.locals.has(name)) {\n    return ctx.locals.get(name)\n  }\n  // Check parameters\n  if (ctx.parameters.has(name)) {\n    return ctx.parameters.get(name)?.type\n  }\n  // Check parent scope\n  if (ctx.parent) {\n    return lookupVariable(name, ctx.parent)\n  }\n  return undefined\n}\n\n// ============================================================================\n// AST Node Helpers\n// ============================================================================\n\n/** Extract location from an Acorn node */\nexport function getLocation(node: Node): { line: number; column: number } {\n  if (node.loc) {\n    return { line: node.loc.start.line, column: node.loc.start.column }\n  }\n  return { line: 1, column: 0 }\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "2A75523C6E6B080464756E2164756E21",
-  "names": []
-}