@razinshafayet/typedjs 0.1.0

package/.vscode/settings.json

@@ -0,0 +1,15 @@
+{
+    "eslint.options": {
+        "overrideConfig": {
+            "languageOptions": {
+                "parser": "/home/razin/.antigravity/extensions/razinshafayet.typedjs-vscode-0.0.2-universal/server/parser.js"
+            },
+            "rules": {
+                "no-op": "error"
+            }
+        },
+        "rulePaths": [
+            "/home/razin/.antigravity/extensions/razinshafayet.typedjs-vscode-0.0.2-universal/server/rules"
+        ]
+    }
+}

package/README.md

@@ -0,0 +1,98 @@
+# TypedJS
+
+A lightweight, runtime-checkable type system for JavaScript. It brings the safety of TypeScript with the simplicity of running directly in Node.js (via a transparent runtime).
+
+## Features
+
+- **Runtime Type Checking**: Catches type errors as your code runs (Development Mode).
+- **Fast Production Mode**: Strips checks for raw JavaScript speed (matching TypeScript performance).
+- **No Build Step**: Run `.js` files directly with the `typedjs` CLI.
+- **Support for Modern Types**: Includes Maps, Sets, Tuples, and Unions.
+
+## Installation
+
+```bash
+npm install -g typedjs
+```
+
+## Usage
+
+### 1. Development Mode (Safe)
+Runs your code with full runtime type checking. Great for debugging.
+
+```bash
+typedjs app.js
+```
+
+### 2. Production Mode (Fast)
+Strips all types and runtime checks. Executes as fast as raw JavaScript. Use this for deployment.
+
+```bash
+typedjs app.js --prod
+```
+
+## Supported Type Annotations
+
+TypedJS supports a subset of TypeScript syntax, focused on runtime-validatable types.
+
+### Primitives
+```javascript
+let name: string = "Razin";
+let age: number = 25;
+let isActive: boolean = true;
+let empty: null = null;
+let notDefined: undefined = undefined;
+let big: bigint = 9007199254740991n;
+let sym: symbol = Symbol("id");
+```
+
+### Interfaces & Objects
+```javascript
+interface User {
+  id: number;
+  name: string;
+  email?: string; // Optional property
+}
+
+let user: User = {
+  id: 1,
+  name: "Razin"
+};
+```
+
+### Type Aliases & Unions
+```javascript
+type ID = string | number;
+type Status = "active" | "inactive" | "pending"; // Literal Unions
+
+let myId: ID = 123;
+let status: Status = "active";
+```
+
+### Arrays & Tuples
+```javascript
+let scores: Array<number> = [10, 20, 30];
+let point: [number, number] = [10, 20]; // Tuple
+```
+
+### Maps & Sets
+```javascript
+let map: Map<string, number> = new Map();
+let set: Set<string> = new Set();
+```
+
+### Functions
+```javascript
+function add(a: number, b: number): number {
+  return a + b;
+}
+```
+
+## How It Works
+
+TypedJS includes a smart parser and runtime generator:
+1.  **Parser**: Reads your TypedJS syntax (using `acorn-typescript`).
+2.  **Analyzer**: Performs static analysis to catch obvious errors early.
+3.  **Generator**:
+    *   **Dev Mode**: Injects `__checkType__` calls around every variable assignment and function call.
+    *   **Prod Mode**: Removes all types and checks, outputting pure optimized JavaScript.

package/eslint.config.cjs

@@ -0,0 +1,23 @@
+const parser = require("/home/razin/.vscode/extensions/razinshafayet.typedjs-vscode-0.0.1/server/parser.js");
+const noOp = require("/home/razin/.vscode/extensions/razinshafayet.typedjs-vscode-0.0.1/server/rules/no-op.js");
+
+const typedjsPlugin = {
+  rules: {
+    "no-op": noOp
+  }
+};
+
+module.exports = [
+  {
+    files: ["**/*.js"],
+    languageOptions: {
+      parser: parser
+    },
+    plugins: {
+      typedjs: typedjsPlugin
+    },
+    rules: {
+      "typedjs/no-op": "error"
+    }
+  }
+];

package/example.js

@@ -0,0 +1,14 @@
+interface User {
+  name: string;
+  age: number;
+}
+
+let person1: User = {
+  name: "Razin",
+  age: 20,
+};
+
+let person2: User = {
+  name: "Shafayet",
+  age: 21,
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@razinshafayet/typedjs",
+    "version": "0.1.0",
+    "description": "Runtime type checking for JavaScript",
+    "main": "src/index.js",
+    "type": "module",
+    "bin": {
+        "typedjs": "./src/cli.js"
+    },
+    "keywords": [
+        "typescript",
+        "javascript",
+        "types",
+        "runtime",
+        "validation",
+        "type-checking",
+        "type-system"
+    ],
+    "author": "Razin Shafayet <curiostymaster77@gmail.com>",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/RazinShafayet2007/typedjs.git"
+    },
+    "bugs": {
+        "url": "https://github.com/RazinShafayet2007/typedjs/issues"
+    },
+    "homepage": "https://github.com/RazinShafayet2007/typedjs#readme",
+    "engines": {
+        "node": ">=14.0.0"
+    },
+    "dependencies": {
+        "acorn": "^8.15.0",
+        "acorn-typescript": "^1.4.13",
+        "escodegen": "^2.1.0",
+        "estree-walker": "^3.0.3"
+    },
+    "devDependencies": {
+        "eslint": "^9.39.2"
+    }
+}

package/src/analyzer/analyzer.js

@@ -0,0 +1,159 @@
+// Updated src/analyzer/analyzer.js - Fixed ESM import + proper walk for enclosing function (no this.parent)
+
+import { walk } from 'estree-walker';
+
+export function staticAnalyze(typeRegistry, ast) {
+  const errors = [];
+
+  // Helper to check if value matches type (for literals/constants)
+  function matchesType(value, type) {
+    if (Array.isArray(type)) { // Union
+      return type.some(member => matchesType(value, member));
+    }
+    if (type.kind === 'literal') {
+      return value === type.value;
+    }
+    if (typeof type === 'string') {
+      if (type === 'any' || type === 'unknown') return true;
+      if (type === 'string') return typeof value === 'string';
+      if (type === 'number') return typeof value === 'number';
+      if (type === 'boolean') return typeof value === 'boolean';
+      if (type === 'null') return value === null;
+      if (type === 'undefined') return value === undefined;
+      if (type === 'bigint') return typeof value === 'bigint';
+      if (type === 'symbol') return typeof value === 'symbol';
+      return false;
+    }
+    // Structured types: skip static check for basic version
+    return true;
+  }
+
+  function checkType(name, valueNode, type, errors) {
+    // 1. Literal Check
+    if (valueNode.type === 'Literal' || valueNode.type === 'BigIntLiteral') {
+        const value = valueNode.value ?? valueNode.bigint;
+        if (!matchesType(value, type)) {
+             errors.push(`[Static type error] Property '${name}' got ${JSON.stringify(value)}, expected ${typeToString(type)}`);
+        }
+        return;
+    }
+
+    // 2. Object Check
+    if (valueNode.type === 'ObjectExpression' && typeof type === 'object' && type.kind !== 'literal') {
+        checkObject(name, valueNode, type, errors);
+        return;
+    }
+
+    // 3. Array Check (Simple)
+    if (valueNode.type === 'ArrayExpression' && type.kind === 'array') {
+        valueNode.elements.forEach((elem, i) => {
+            if (elem) checkType(`${name}[${i}]`, elem, type.elementType, errors);
+        });
+        return;
+    }
+  }
+
+  function checkObject(name, objectExpr, type, errors) {
+    if (typeof type !== 'object' || type === null) return; // Can't check primitive vs object here easily without more logic
+
+    // Convert AST ObjectExpression props to a map for easy lookup
+    const props = {};
+    objectExpr.properties.forEach(p => {
+        if (p.type === 'Property' && p.key.type === 'Identifier') {
+            props[p.key.name] = p.value;
+        }
+    });
+
+    // Check against interface definition (type is the shape object)
+    for (const [key, expectedType] of Object.entries(type)) {
+        const isOptional = expectedType.kind === 'optional';
+        const actualType = isOptional ? expectedType.type : expectedType;
+
+        if (!(key in props)) {
+            if (!isOptional) {
+                errors.push(`[Static type error] Property '${key}' is missing in object '${name}' (expected type ${typeToString(type)})`);
+            }
+            continue;
+        }
+
+        const valueNode = props[key];
+        checkType(`${name}.${key}`, valueNode, actualType, errors);
+    }
+  }
+
+  // Map variable names to types
+  const varTypes = {};
+  typeRegistry.forEach(entry => {
+    if (entry.kind === 'variable') {
+      varTypes[entry.name] = entry.type;
+    }
+  });
+
+  // Map function names to return types
+  const funcReturnTypes = {};
+  typeRegistry.forEach(entry => {
+    if (entry.kind === 'function' && entry.returnType !== 'any') {
+      funcReturnTypes[entry.name] = entry.returnType;
+    }
+  });
+
+  let currentFuncName = null;
+
+  walk(ast, {
+    enter(node) {
+      // Track current function
+      if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+        currentFuncName = node.id?.name || null;
+      }
+
+      // Check variable initializer (only simple literals)
+      if (node.type === 'VariableDeclarator' && node.init && varTypes[node.id.name]) {
+        if (node.init.type === 'Literal' || node.init.type === 'BigIntLiteral') {
+          const value = node.init.value ?? node.init.bigint;
+          const declaredType = varTypes[node.id.name];
+          if (!matchesType(value, declaredType)) {
+            errors.push(`[Static type error] Variable '${node.id.name}' initializer ${JSON.stringify(value)} does not match declared type ${typeToString(declaredType)}`);
+          }
+        } else if (node.init.type === 'ObjectExpression') {
+           const declaredType = varTypes[node.id.name];
+           checkObject(node.id.name, node.init, declaredType, errors);
+        }
+      }
+
+      // Check literal return
+      if (node.type === 'ReturnStatement' && node.argument && (node.argument.type === 'Literal' || node.argument.type === 'BigIntLiteral') && currentFuncName && funcReturnTypes[currentFuncName]) {
+        const value = node.argument.value ?? node.argument.bigint;
+        const returnType = funcReturnTypes[currentFuncName];
+        if (!matchesType(value, returnType)) {
+          errors.push(`[Static type error] Function '${currentFuncName}' returns ${JSON.stringify(value)} which does not match return type ${typeToString(returnType)}`);
+        }
+      }
+    },
+    leave(node) {
+      // Clear current function on leave
+      if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+        currentFuncName = null;
+      }
+    }
+  });
+
+  // Helper for nice type strings in errors (reuse from generator or simple)
+  function typeToString(t) {
+    if (Array.isArray(t)) return t.map(typeToString).join(' | ');
+    if (typeof t === 'object' && t?.kind === 'literal') return JSON.stringify(t.value);
+    return t;
+  }
+
+  // Print static errors
+  if (errors.length > 0) {
+    console.log('\n--- Static Type Errors ---');
+    errors.forEach(err => console.log(err));
+    console.log('--- End Static Errors ---\n');
+  }
+
+  return errors.length === 0;
+}
+
+export function analyze(typeRegistry) {
+  return typeRegistry;
+}

package/src/cli.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import { parseCode } from "./parser/parser.js";
+import { staticAnalyze, analyze } from "./analyzer/analyzer.js"; // Add staticAnalyze
+import { generate } from "./generator/generator.js";
+
+const args = process.argv.slice(2);
+
+const isProd = args.includes('--prod');
+const fileArg = args.find(a => !a.startsWith('--'));
+
+if (!fileArg) {
+  console.error("Usage: typedjs <file.js> [--prod]");
+  process.exit(1);
+}
+
+const filePath = path.resolve(fileArg);
+const source = fs.readFileSync(filePath, "utf-8");
+
+const { ast, typeRegistry } = parseCode(source);
+
+// Static analysis (Always run it, but in prod it's CRITICAL)
+const staticErrors = staticAnalyze(typeRegistry, ast);
+if (!staticErrors && isProd) { // staticAnalyze returns false if errors found (wait, logic check)
+   // staticAnalyze returns boolean? Let's check. 
+   // It returns `errors.length === 0`. So true means OK.
+   console.error("Build failed due to static type errors.");
+   process.exit(1);
+}
+
+// Old minimal analyze (deprecated but keeping for now)
+analyze(typeRegistry);
+
+const output = generate(ast, typeRegistry, isProd ? 'production' : 'development');
+
+const tmpFile = path.resolve("./typedjs_temp.js");
+fs.writeFileSync(tmpFile, output);
+
+await import(tmpFile);
+
+fs.unlinkSync(tmpFile);

package/src/generator/generator.js

@@ -0,0 +1,261 @@
+// Updated src/generator/generator.js - Added runtime checks for null, undefined, bigint, symbol
+
+import escodegen from 'escodegen';
+import { walk } from 'estree-walker';
+
+function transformAst(ast, typeRegistry, mode) {
+  // Remove compile-time TS nodes
+  if (ast.body) {
+    ast.body = ast.body.filter(node => 
+      node.type !== 'TSInterfaceDeclaration' &&
+      node.type !== 'TSTypeAliasDeclaration'
+    );
+  }
+
+  // If production mode, stop here! (No runtime checks)
+  if (mode === 'production') {
+    return ast;
+  }
+
+  // Helpers for check injection
+  function createCheckCall(name, valueExpr, type) {
+    return {
+      type: 'CallExpression',
+      callee: { type: 'Identifier', name: '__checkType__' },
+      arguments: [
+        { type: 'Literal', value: name },
+        valueExpr,
+        { type: 'Literal', value: JSON.stringify(type) }
+      ]
+    };
+  }
+
+  function createReturnCheckCall(valueExpr, type) {
+    return {
+      type: 'CallExpression',
+      callee: { type: 'Identifier', name: '__checkReturnType__' },
+      arguments: [
+        valueExpr,
+        { type: 'Literal', value: JSON.stringify(type) }
+      ]
+    };
+  }
+
+  const funcTypes = {};
+  typeRegistry.forEach(entry => {
+    if (entry.kind === 'function') {
+      funcTypes[entry.name] = entry;
+    }
+  });
+
+  walk(ast, {
+    enter(node) {
+      if (node.typeAnnotation) node.typeAnnotation = null;
+      if (node.returnType) node.returnType = null;
+
+      if (node.type === 'FunctionDeclaration' && node.id && funcTypes[node.id.name]?.params?.length > 0) {
+        const params = funcTypes[node.id.name].params;
+        const checkStmts = params.map(p => ({
+          type: 'VariableDeclaration',
+          kind: 'const',
+          declarations: [{
+            type: 'VariableDeclarator',
+            id: { type: 'Identifier', name: p.name },
+            init: createCheckCall(p.name, { type: 'Identifier', name: `__arg_${p.name}` }, p.type)
+          }]
+        }));
+
+        node.params = node.params.map((param, i) => {
+          if (params[i]) param.name = `__arg_${param.name}`;
+          return param;
+        });
+
+        node.body.body = [...checkStmts, ...node.body.body];
+      }
+    },
+    leave(node, parent) {
+      if (node.type === 'ReturnStatement' && parent?.type === 'BlockStatement' && parent.parent?.type === 'FunctionDeclaration' && parent.parent.id) {
+        const funcName = parent.parent.id.name;
+        const returnType = funcTypes[funcName]?.returnType;
+        if (returnType && returnType !== 'any' && node.argument) {
+          node.argument = createReturnCheckCall(node.argument, returnType);
+        }
+      }
+    }
+  });
+
+  return ast;
+}
+
+export function generate(ast, typeRegistry, mode = 'development') {
+  const transformedAst = transformAst(ast, typeRegistry, mode);
+
+  let transformed = escodegen.generate(transformedAst, {
+    format: { indent: { style: '  ' } },
+    comment: true,
+  });
+
+  if (mode === 'production') {
+    return transformed;
+  }
+
+  const helpers = `
+function typeToString(t) {
+  if (Array.isArray(t)) {
+    return t.map(typeToString).join(' | ');
+  }
+  if (typeof t === 'object' && t !== null) {
+    if (t.kind === 'literal') return JSON.stringify(t.value);
+    if (t.kind === 'array') return 'Array<' + typeToString(t.elementType) + '>';
+    if (t.kind === 'map') return 'Map<' + typeToString(t.keyType) + ', ' + typeToString(t.valueType) + '>';
+    if (t.kind === 'set') return 'Set<' + typeToString(t.elementType) + '>';
+    if (t.kind === 'tuple') return '[' + t.elements.map(typeToString).join(', ') + ']';
+    if (t.kind === 'optional') return typeToString(t.type) + '?';
+    return '{' + Object.keys(t).map(k => k + ': ' + typeToString(t[k])).join(', ') + '}';
+  }
+  return t;
+}
+
+function __checkType__(name, value, typeJson) {
+  const type = JSON.parse(typeJson);
+  const typeStr = typeToString(type);
+
+  // Union
+  if (Array.isArray(type)) {
+    const ok = type.some(member => {
+      if (typeof member === 'string') {
+        if (member === 'string') return typeof value === 'string';
+        if (member === 'number') return typeof value === 'number';
+        if (member === 'boolean') return typeof value === 'boolean';
+        if (member === 'null') return value === null;
+        if (member === 'undefined') return value === undefined;
+        if (member === 'bigint') return typeof value === 'bigint';
+        if (member === 'symbol') return typeof value === 'symbol';
+        if (member === 'unknown') return true;
+        return false;
+      }
+      if (member.kind === 'literal') {
+        return value === member.value;
+      }
+      return false;
+    });
+    if (!ok) {
+      console.warn('[Type warning] ' + name + ' expected ' + typeStr + ', got ' + JSON.stringify(value));
+    }
+    return value;
+  }
+
+  // Single literal
+  if (type.kind === 'literal') {
+    if (value !== type.value) {
+      console.warn('[Type warning] ' + name + ' expected ' + typeStr + ', got ' + JSON.stringify(value));
+    }
+    return value;
+  }
+
+  // Primitive (including new ones)
+  if (typeof type === 'string') {
+    if (type === 'any') return value;
+    const allowed = type.split('|').map(s => s.trim());
+    const ok = allowed.some(a => {
+      if (a === 'string') return typeof value === 'string';
+      if (a === 'number') return typeof value === 'number';
+      if (a === 'boolean') return typeof value === 'boolean';
+      if (a === 'null') return value === null;
+      if (a === 'undefined') return value === undefined;
+      if (a === 'bigint') return typeof value === 'bigint';
+      if (a === 'symbol') return typeof value === 'symbol';
+      if (a === 'unknown') return true;
+      return false;
+    });
+    if (!ok) console.warn('[Type warning] ' + name + ' expected ' + typeStr + ', got ' + typeof value);
+    return value;
+  }
+
+  // Structured types (unchanged)
+  if (typeof type === 'object' && type !== null) {
+    if (type.kind === 'array') {
+      if (!Array.isArray(value)) {
+        console.warn('[Type warning] ' + name + ' expected ' + typeStr + ', got ' + typeof value);
+        return value;
+      }
+      value.forEach((item, i) => {
+        __checkType__(name + '[' + i + ']', item, JSON.stringify(type.elementType));
+      });
+      return value;
+    }
+
+    if (type.kind === 'map') {
+      if (!(value instanceof Map)) {
+        console.warn('[Type warning] ' + name + ' expected ' + typeStr + ', got ' + typeof value);
+        return value;
+      }
+      for (const [k, v] of value.entries()) {
+        __checkType__(name + '.key', k, JSON.stringify(type.keyType));
+        __checkType__(name + '.value', v, JSON.stringify(type.valueType));
+      }
+      return value;
+    }
+
+    if (type.kind === 'set') {
+      if (!(value instanceof Set)) {
+        console.warn('[Type warning] ' + name + ' expected ' + typeStr + ', got ' + typeof value);
+        return value;
+      }
+      let i = 0;
+      for (const item of value) {
+        __checkType__(name + '[#' + i + ']', item, JSON.stringify(type.elementType));
+        i++;
+      }
+      return value;
+    }
+
+    if (type.kind === 'tuple') {
+      if (!Array.isArray(value)) {
+        console.warn('[Type warning] ' + name + ' expected ' + typeStr + ', got ' + typeof value);
+        return value;
+      }
+      if (value.length !== type.elements.length) {
+        console.warn('[Type warning] ' + name + ' expected tuple length ' + type.elements.length + ', got ' + value.length);
+      }
+      type.elements.forEach((et, i) => {
+        if (i < value.length) {
+          __checkType__(name + '[' + i + ']', value[i], JSON.stringify(et));
+        }
+      });
+      return value;
+    }
+
+    if (type.kind === 'optional') {
+      if (value === undefined) return value;
+      return __checkType__(name, value, JSON.stringify(type.type));
+    }
+
+    // Object shape
+    if (typeof value !== 'object' || value === null) {
+      console.warn('[Type warning] ' + name + ' expected ' + typeStr + ', got ' + typeof value);
+      return value;
+    }
+    for (const [prop, pt] of Object.entries(type)) {
+      const actualType = pt.kind === 'optional' ? pt.type : pt;
+      if (pt.kind === 'optional' && value[prop] === undefined) continue;
+      __checkType__(name + '.' + prop, value[prop], JSON.stringify(actualType));
+    }
+    return value;
+  }
+
+  return value;
+}
+
+function __checkReturnType__(value, typeJson) {
+  return __checkType__('return', value, typeJson);
+}
+`;
+
+  const varChecks = typeRegistry
+    .filter(e => e.kind === 'variable')
+    .map(({ name, type }) => `__checkType__('${name}', ${name}, ${JSON.stringify(JSON.stringify(type))});`)
+    .join('\n');
+
+  return `${helpers}\n${transformed}\n${varChecks}`;
+}

package/src/parser/parser.js

@@ -0,0 +1,136 @@
+// Updated src/parser/parser.js - Added support for null, undefined, bigint, symbol
+
+import { Parser } from "acorn";
+import ts from "acorn-typescript";
+import { walk } from 'estree-walker';
+
+/**
+ * Convert a TypeScript AST type node into structured representation
+ */
+function tsTypeToString(typeNode, registry = []) {
+  switch (typeNode.type) {
+    case "TSNullKeyword":
+      return "null";
+    case "TSUndefinedKeyword":
+      return "undefined";
+    case "TSBigIntKeyword":
+      return "bigint";
+    case "TSSymbolKeyword":
+      return "symbol";
+    case "TSStringKeyword":
+      return "string";
+    case "TSNumberKeyword":
+      return "number";
+    case "TSBooleanKeyword":
+      return "boolean";
+    case "TSLiteralType":
+      return { kind: 'literal', value: typeNode.literal.value };
+    case "TSTypeReference":
+      const refName = typeNode.typeName.name;
+      if (refName === 'Array' && typeNode.typeParameters?.params?.length > 0) {
+        return { kind: 'array', elementType: tsTypeToString(typeNode.typeParameters.params[0], registry) };
+      }
+      if (refName === 'Map' && typeNode.typeParameters?.params?.length === 2) {
+        return { kind: 'map', keyType: tsTypeToString(typeNode.typeParameters.params[0], registry), valueType: tsTypeToString(typeNode.typeParameters.params[1], registry) };
+      }
+      if (refName === 'Set' && typeNode.typeParameters?.params?.length > 0) {
+        return { kind: 'set', elementType: tsTypeToString(typeNode.typeParameters.params[0], registry) };
+      }
+      const iface = registry.find(e => e.kind === 'interface' && e.name === refName);
+      return iface ? { ...iface.shape } : refName;
+    case "TSUnionType":
+      return typeNode.types.map(t => tsTypeToString(t, registry));
+    case "TSTypeLiteral":
+      const shape = {};
+      typeNode.members.forEach(m => {
+        if (m.type === 'TSPropertySignature') {
+          const name = m.key.name;
+          const optional = !!m.optional;
+          const propType = tsTypeToString(m.typeAnnotation.typeAnnotation, registry);
+          shape[name] = optional ? { kind: 'optional', type: propType } : propType;
+        }
+      });
+      return shape;
+    case "TSTupleType":
+      return { kind: 'tuple', elements: typeNode.elementTypes.map(et => tsTypeToString(et, registry)) };
+    default:
+      return "unknown";
+  }
+}
+
+/**
+ * Parse code and collect type registry
+ */
+export function parseCode(source) {
+  const parser = Parser.extend(ts());
+  const ast = parser.parse(source, { ecmaVersion: 2024, sourceType: "module" });
+
+  const typeRegistry = [];
+
+  // Pass 1: Interfaces + type aliases
+  walk(ast, {
+    enter(node) {
+      if (node.type === "TSInterfaceDeclaration") {
+        const shape = {};
+        node.body.body.forEach(m => {
+          if (m.type === 'TSPropertySignature') {
+            const name = m.key.name;
+            const optional = !!m.optional;
+            const propType = tsTypeToString(m.typeAnnotation.typeAnnotation, typeRegistry);
+            shape[name] = optional ? { kind: 'optional', type: propType } : propType;
+          }
+        });
+        typeRegistry.push({ kind: "interface", name: node.id.name, shape });
+      } else if (node.type === "TSTypeAliasDeclaration") {
+        const aliasType = tsTypeToString(node.typeAnnotation, typeRegistry);
+        typeRegistry.push({ kind: "typeAlias", name: node.id.name, type: aliasType });
+      }
+    }
+  });
+
+  // Pass 2: Variables + functions (resolve aliases)
+  walk(ast, {
+    enter(node) {
+      if (node.type === "VariableDeclaration") {
+        for (const decl of node.declarations) {
+          if (decl.id.typeAnnotation) {
+            let type = tsTypeToString(decl.id.typeAnnotation.typeAnnotation, typeRegistry);
+            if (typeof type === 'string') {
+              const alias = typeRegistry.find(e => e.kind === 'typeAlias' && e.name === type);
+              if (alias) type = alias.type;
+            }
+            typeRegistry.push({ kind: "variable", name: decl.id.name, type });
+          }
+        }
+      } else if (node.type === "FunctionDeclaration") {
+        const funcName = node.id.name;
+        const params = node.params.map(p => {
+          if (p.typeAnnotation) {
+            let type = tsTypeToString(p.typeAnnotation.typeAnnotation, typeRegistry);
+            if (typeof type === 'string') {
+              const alias = typeRegistry.find(e => e.kind === 'typeAlias' && e.name === type);
+              if (alias) type = alias.type;
+            }
+            return { name: p.name, type };
+          }
+          return null;
+        }).filter(Boolean);
+
+        let returnType = "any";
+        if (node.returnType) {
+          returnType = tsTypeToString(node.returnType.typeAnnotation, typeRegistry);
+          if (typeof returnType === 'string') {
+            const alias = typeRegistry.find(e => e.kind === 'typeAlias' && e.name === returnType);
+            if (alias) returnType = alias.type;
+          }
+        }
+
+        if (params.length > 0 || returnType !== "any") {
+          typeRegistry.push({ kind: "function", name: funcName, params, returnType });
+        }
+      }
+    }
+  });
+
+  return { ast, typeRegistry };
+}