tjs-lang 0.6.7 → 0.6.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tjs-lang",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "description": "Type-safe JavaScript dialect with runtime validation, sandboxed VM execution, and AI agent orchestration. Transpiles TypeScript to validated JS with fuel-metered execution for untrusted code.",
   "keywords": [
     "typescript",

package/src/cli/tjs.ts

@@ -20,7 +20,7 @@ import { emit } from './commands/emit'
 import { convert } from './commands/convert'
 import { test } from './commands/test'
 
-const VERSION = '0.6.7'
+const VERSION = '0.6.8'
 
 const HELP = `
 tjs - Typed JavaScript CLI

package/src/lang/codegen.test.ts

@@ -2043,3 +2043,47 @@ describe('TS overloads → TJS → JS full pipeline', () => {
     }
   })
 })
+
+describe('rest parameter metadata', () => {
+  it('should capture typed rest param in metadata', () => {
+    const result = tjs(`function sum(...nums: [0]) -> 0 { return 0 }`, {
+      runTests: false,
+    })
+    const info = result.types.sum
+    expect(info.params.nums).toBeDefined()
+    expect(info.params.nums.type.kind).toBe('array')
+    expect(info.params.nums.type.items?.kind).toBe('integer')
+    expect(info.params.nums.required).toBe(false)
+  })
+
+  it('should capture rest param with float array type', () => {
+    const result = tjs(
+      `function mean(...values: [1.0, 2.0]) -> 0.0 { return 0 }`,
+      { runTests: false }
+    )
+    const info = result.types.mean
+    expect(info.params.values).toBeDefined()
+    expect(info.params.values.type.kind).toBe('array')
+    expect(info.params.values.type.items?.kind).toBe('number')
+  })
+
+  it('should capture heterogeneous rest param as union', () => {
+    const result = tjs(
+      `function log(...args: ['hello', 42, true]) -> 0 { return 0 }`,
+      { runTests: false }
+    )
+    const info = result.types.log
+    expect(info.params.args.type.kind).toBe('array')
+    expect(info.params.args.type.items?.kind).toBe('union')
+    expect(info.params.args.type.items?.members).toHaveLength(3)
+  })
+
+  it('should capture untyped rest param as bare array', () => {
+    const result = tjs(`function collect(...args) { return args }`, {
+      runTests: false,
+    })
+    const info = result.types.collect
+    expect(info.params.args).toBeDefined()
+    expect(info.params.args.type.kind).toBe('array')
+  })
+})

package/src/lang/emitters/js-tests.ts

@@ -1105,9 +1105,30 @@ function extractParamExamples(paramsStr: string): string[] {
   const params = splitParams(paramsStr)
 
   for (const param of params) {
+    const trimmed = param.trim()
+
+    // Rest parameter: ...name: [examples] — spread the array elements as individual args
+    const restMatch = trimmed.match(/^\.\.\.(\w+)\s*[:=]\s*(\[.+\])$/)
+    if (restMatch) {
+      try {
+        const arr = new Function(`return ${restMatch[2]}`)()
+        if (Array.isArray(arr)) {
+          for (const el of arr) {
+            examples.push(JSON.stringify(el))
+          }
+        }
+      } catch {
+        // Can't parse — skip rest param examples
+      }
+      continue
+    }
+
+    // Bare rest param without type: ...name — skip (no example to use)
+    if (trimmed.startsWith('...')) continue
+
     // Match: name: example or name = example (with optional safety markers)
     // Handle: (? name: example) or (! name: example)
-    const match = param.match(/(?:\(\s*[?!]\s*)?(\w+)\s*[:=]\s*(.+?)(?:\))?$/)
+    const match = trimmed.match(/(?:\(\s*[?!]\s*)?(\w+)\s*[:=]\s*(.+?)(?:\))?$/)
     if (match) {
       examples.push(match[2].trim())
     } else {

package/src/lang/emitters/js.ts

@@ -257,6 +257,47 @@ function extractFunctionTypeInfo(
             }
           }
         }
+      } else if (
+        param.type === 'RestElement' &&
+        param.argument?.type === 'Identifier'
+      ) {
+        // Handle rest parameters: ...args: [0]
+        // The type annotation was stripped by preprocessing (JS forbids
+        // defaults on rest params), so extract it from the original source
+        const restName = param.argument.name
+        const restTypeMatch = originalSource.match(
+          new RegExp(`\\.\\.\\.${restName}\\s*:\\s*([^)]+?)\\s*\\)`)
+        )
+        if (restTypeMatch) {
+          try {
+            const typeExpr = parseExpressionAt(restTypeMatch[1].trim(), 0, {
+              ecmaVersion: 2022,
+            })
+            const restItemType = inferTypeFromValue(typeExpr as any)
+            params[restName] = {
+              name: restName,
+              type: restItemType,
+              required: false,
+              description: tdoc.params[restName],
+            }
+          } catch {
+            // If we can't parse the type, emit as any array
+            params[restName] = {
+              name: restName,
+              type: { kind: 'array' },
+              required: false,
+              description: tdoc.params[restName],
+            }
+          }
+        } else {
+          // No type annotation — bare rest param
+          params[restName] = {
+            name: restName,
+            type: { kind: 'array' },
+            required: false,
+            description: tdoc.params[restName],
+          }
+        }
       }
     }
   }

package/src/lang/inference.ts

@@ -48,9 +48,26 @@ export function inferTypeFromValue(node: Expression): TypeDescriptor {
       if (elements.length === 0) {
         return { kind: 'array', items: { kind: 'any' } }
       }
-      // Use first element as the item type
-      const itemType = inferTypeFromValue(elements[0])
-      return { kind: 'array', items: itemType }
+      // Infer type from all elements — if homogeneous, use that type;
+      // if heterogeneous, produce a union of distinct kinds
+      const itemTypes = elements
+        .filter((el) => el != null)
+        .map((el) => inferTypeFromValue(el))
+      if (itemTypes.length === 0) {
+        return { kind: 'array', items: { kind: 'any' } }
+      }
+      // Deduplicate by structure
+      const seen = new Map<string, TypeDescriptor>()
+      for (const t of itemTypes) {
+        const key = JSON.stringify(t)
+        if (!seen.has(key)) seen.set(key, t)
+      }
+      const unique = [...seen.values()]
+      const items =
+        unique.length === 1
+          ? unique[0]
+          : { kind: 'union' as const, members: unique }
+      return { kind: 'array', items }
     }
 
     case 'ObjectExpression': {

package/src/lang/parser-params.ts

@@ -933,6 +933,17 @@ function processParamString(
       return `[ ${processedInner} ]`
     }
 
+    // Handle rest parameters: ...args: [0] -> ...args (strip type, JS forbids defaults on rest)
+    // The type annotation is still captured by extractFunctionTypeInfo for __tjs metadata
+    if (trimmed.startsWith('...')) {
+      const restColonPos = findTopLevelColon(trimmed)
+      if (restColonPos !== -1) {
+        const restName = trimmed.slice(0, restColonPos).trim()
+        return restName
+      }
+      return param
+    }
+
     // Handle optional param syntax: x?: type -> x = type (not required)
     const optionalMatch = trimmed.match(/^(\w+)\s*\?\s*:\s*(.+)$/)
     if (optionalMatch) {

package/src/lang/parser.test.ts

@@ -35,6 +35,21 @@ describe('Transpiler', () => {
       )
     })
 
+    it('should strip type annotation from rest params', () => {
+      // JS forbids default values on rest params, so : annotation must be stripped
+      const result = preprocess(`function sum(...nums: [0]) { }`)
+      expect(result.source).toContain('...nums)')
+      expect(result.source).not.toContain('...nums =')
+    })
+
+    it('should handle rest param with array type example', () => {
+      const result = preprocess(
+        `function mean(...values: [1.0, 2.0, 3.0]) -> 2.0 { return 0 }`
+      )
+      expect(result.source).toContain('...values)')
+      expect(result.source).not.toContain('[1.0')
+    })
+
     it('should allow required params after optional params', () => {
       // TypeScript permits this pattern, and fromTS can produce it when
       // earlier params degrade to any. TJS should accept it.