tjs-lang 0.2.7 → 0.3.0

package/editors/codemirror/ajs-language.ts

@@ -1353,6 +1353,17 @@ function getPlaceholderForParam(name: string, info: any): string {
     return String(ex)
   }
 
+  // Then check for examples from schema metadata (use first as placeholder)
+  const examples = info.type?.examples || info.examples
+  if (Array.isArray(examples) && examples.length > 0) {
+    const ex = examples[0]
+    if (typeof ex === 'string') return `'${ex}'`
+    if (typeof ex === 'number' || typeof ex === 'boolean') return String(ex)
+    if (Array.isArray(ex)) return JSON.stringify(ex)
+    if (typeof ex === 'object') return JSON.stringify(ex)
+    return String(ex)
+  }
+
   // Then check for explicit default value
   if (info.default !== undefined && info.default !== null) {
     const def = info.default
@@ -1481,12 +1492,27 @@ function tjsCompletionSource(config: AutocompleteConfig = {}) {
             // Handle both { type: 'string' } and { kind: 'string' } formats
             const returnType =
               meta.returns?.type || meta.returns?.kind || 'void'
+
+            // Build info string with description and parameter examples
+            let infoText = meta.description || ''
+            for (const [pName, pInfo] of paramEntries as [string, any][]) {
+              const pExamples = pInfo.type?.examples || pInfo.examples
+              if (Array.isArray(pExamples) && pExamples.length > 0) {
+                const formatted = pExamples
+                  .map((ex: any) =>
+                    typeof ex === 'string' ? `'${ex}'` : String(ex)
+                  )
+                  .join(', ')
+                infoText += `${infoText ? '\n' : ''}${pName}: e.g. ${formatted}`
+              }
+            }
+
             options.push(
               snippetCompletion(`${name}(${snippetParams})`, {
                 label: name,
                 type: 'function',
                 detail: `(${paramList}) -> ${returnType}`,
-                info: meta.description,
+                info: infoText || undefined,
                 boost: 2, // Boost user-defined functions above globals
               })
             )

package/editors/codemirror/autocomplete.test.ts

@@ -432,8 +432,8 @@ const after = 2
 
       expect(metadata).toBeDefined()
       // metadata is now keyed by function name
-      expect(metadata?.add?.params?.a?.type?.kind).toBe('number')
-      expect(metadata?.add?.params?.b?.type?.kind).toBe('number')
+      expect(metadata?.add?.params?.a?.type?.kind).toBe('integer')
+      expect(metadata?.add?.params?.b?.type?.kind).toBe('integer')
     })
 
     it('extracts example-based types', () => {
@@ -445,7 +445,7 @@ const after = 2
       expect(metadata).toBeDefined()
       // metadata is now keyed by function name
       expect(metadata?.greet?.params?.name?.type?.kind).toBe('string')
-      expect(metadata?.greet?.params?.times?.type?.kind).toBe('number')
+      expect(metadata?.greet?.params?.times?.type?.kind).toBe('integer')
       expect(metadata?.greet?.params?.times?.default).toBe(1)
     })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tjs-lang",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "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/lang/codegen.test.ts

@@ -54,7 +54,7 @@ describe('TS → TJS conversion quality', () => {
       const ts = `function sum(nums: number[]): number { return nums.reduce((a, b) => a + b, 0) }`
       const { code } = fromTS(ts, { emitTJS: true })
 
-      expect(code).toContain('nums: [0]')
+      expect(code).toContain('nums: [0.0]')
     })
 
     it('converts object param correctly', () => {
@@ -62,7 +62,7 @@ describe('TS → TJS conversion quality', () => {
       const { code } = fromTS(ts, { emitTJS: true })
 
       expect(code).toContain("name: ''")
-      expect(code).toContain('age: 0')
+      expect(code).toContain('age: 0.0')
     })
 
     it('handles multiple params in order', () => {
@@ -70,7 +70,7 @@ describe('TS → TJS conversion quality', () => {
       const { code } = fromTS(ts, { emitTJS: true })
 
       // Should have both params with colon syntax
-      expect(code).toMatch(/add\(a: 0, b: 0\)/)
+      expect(code).toMatch(/add\(a: 0\.0, b: 0\.0\)/)
     })
 
     it('handles mixed required and optional params', () => {
@@ -228,7 +228,7 @@ class Calculator {
 `
       const { code } = fromTS(ts, { emitTJS: true })
 
-      expect(code).toContain('add(a: 0, b: 0) -! 0')
+      expect(code).toContain('add(a: 0.0, b: 0.0) -! 0.0')
     })
 
     it('converts getters and setters', () => {
@@ -269,7 +269,7 @@ class MathUtils {
 `
       const { code } = fromTS(ts, { emitTJS: true })
 
-      expect(code).toContain('static double(x: 0) -! 0')
+      expect(code).toContain('static double(x: 0.0) -! 0.0')
     })
 
     it('converts async methods', () => {
@@ -396,7 +396,7 @@ describe('TJS → JS transpilation quality', () => {
 
       expect(code).toContain('__tjs')
       // types is now keyed by function name
-      expect(types?.double?.returns?.kind).toBe('number')
+      expect(types?.double?.returns?.kind).toBe('integer')
     })
 
     it('marks required params correctly', () => {
@@ -561,8 +561,8 @@ function greet(name: string): string {
       const { code } = fromTS(ts, { emitTJS: true })
 
       // All functions should be present (TS transpiler uses -! to skip signature tests)
-      expect(code).toContain('function add(a: 0, b: 0) -! 0')
-      expect(code).toContain('function multiply(a: 0, b: 0) -! 0')
+      expect(code).toContain('function add(a: 0.0, b: 0.0) -! 0.0')
+      expect(code).toContain('function multiply(a: 0.0, b: 0.0) -! 0.0')
       expect(code).toContain("function greet(name: '') -! ''")
 
       // Should be valid TJS (no TypeScript syntax remaining)
@@ -738,7 +738,7 @@ function greet(name: '', excited = false) -! '' {
       // add function
       expect(types?.add?.params?.a?.required).toBe(true)
       expect(types?.add?.params?.b?.required).toBe(true)
-      expect(types?.add?.returns?.kind).toBe('number')
+      expect(types?.add?.returns?.kind).toBe('integer')
 
       // greet function
       expect(types?.greet?.params?.name?.required).toBe(true)
@@ -1146,7 +1146,7 @@ function processUser(user: { name: string; age: number }): string {
       // TS → TJS
       const { code: tjsCode } = fromTS(ts, { emitTJS: true })
       expect(tjsCode).toContain("name: ''")
-      expect(tjsCode).toContain('age: 0')
+      expect(tjsCode).toContain('age: 0.0')
 
       // TJS → JS (already has -! from TS transpiler)
       const { code: jsCode, types } = tjs(tjsCode)
@@ -1386,7 +1386,7 @@ function getData(id: 0) -! { value: 0 } {
       expect(result.value).toBeUndefined()
 
       // But error properties are accessible
-      expect(result.message).toContain('Expected number')
+      expect(result.message).toContain('Expected integer')
     })
   })
 

package/src/lang/emitters/from-ts.ts

@@ -137,7 +137,7 @@ function typeToExample(
     case ts.SyntaxKind.StringKeyword:
       return "''"
     case ts.SyntaxKind.NumberKeyword:
-      return '0'
+      return '0.0'
     case ts.SyntaxKind.BooleanKeyword:
       return 'true'
     case ts.SyntaxKind.NullKeyword:

package/src/lang/emitters/js.ts

@@ -17,6 +17,33 @@
  *     params: { name: { type: 'string', required: true, example: 'world' } },
  *     returns: { type: 'string' }
  *   }
+ *
+ * TODO: Self-contained output (no runtime dependency)
+ * =====================================================
+ * Currently, transpiled code references `globalThis.__tjs` for:
+ *   - __tjs.pushStack() / popStack() - debug stack traces
+ *   - __tjs.typeError() - monadic error creation
+ *   - __tjs.Is() / IsNot() - structural equality (when == / != used)
+ *
+ * This requires either:
+ *   1. The runtime to be installed via installRuntime()
+ *   2. A stub to be provided (e.g., playground's inline stub)
+ *
+ * The ideal is that TJS produces completely independent code that only needs
+ * things it semantically needs (like fetch for HTTP calls). The runtime
+ * functions above are ~30 lines and could be inlined when used:
+ *
+ *   - typeError: Create a simple Error with extra properties
+ *   - pushStack/popStack: Could be no-ops in production, or inline array ops
+ *   - Is/IsNot: ~20 lines for deep structural equality
+ *
+ * Options to explore:
+ *   1. Inline minimal runtime when needed (adds ~1KB unminified per output)
+ *   2. Add transpile option: { standalone: true } to emit self-contained code
+ *   3. Tree-shake: only inline the specific functions actually referenced
+ *
+ * See also: demo/src/tjs-playground.ts which has a manual __tjs stub that
+ * must stay in sync with the runtime - a symptom of this leaky abstraction.
  */
 
 import type { FunctionDeclaration, Program } from 'acorn'
@@ -25,6 +52,7 @@ import { parse, extractTDoc, preprocess } from '../parser'
 import type { TypeDescriptor, ParameterDescriptor } from '../types'
 import { inferTypeFromValue, parseParameter } from '../inference'
 import { extractTests } from '../tests'
+import { compileToWasm } from '../wasm'
 
 export interface TJSTranspileOptions {
   /** Filename for error messages */
@@ -86,8 +114,13 @@ export interface TJSTranspileResult {
   testCount?: number
   /** Test results (when runTests is true or 'only') */
   testResults?: TestResult[]
-  /** WASM blocks extracted from source (need to be compiled before execution) */
-  wasmBlocks?: import('../parser').WasmBlock[]
+  /** WASM compilation results (for debugging/inspection) */
+  wasmCompiled?: {
+    id: string
+    success: boolean
+    error?: string
+    byteLength?: number
+  }[]
 }
 
 export interface TJSTypeInfo {
@@ -583,6 +616,19 @@ export function transpileToJS(
     }
   }
 
+  // Compile WASM blocks at transpile time and embed in output
+  let wasmCompiled:
+    | { id: string; success: boolean; error?: string; byteLength?: number }[]
+    | undefined
+  if (preprocessed.wasmBlocks.length > 0) {
+    wasmCompiled = []
+    const wasmBootstrap = generateWasmBootstrap(preprocessed.wasmBlocks)
+    if (wasmBootstrap.code) {
+      code = wasmBootstrap.code + '\n' + code
+    }
+    wasmCompiled = wasmBootstrap.results
+  }
+
   return {
     code,
     types: allTypes,
@@ -591,8 +637,7 @@ export function transpileToJS(
     testRunner: tests.length > 0 ? testRunner : undefined,
     testCount: tests.length > 0 ? tests.length : undefined,
     testResults,
-    wasmBlocks:
-      preprocessed.wasmBlocks.length > 0 ? preprocessed.wasmBlocks : undefined,
+    wasmCompiled,
   }
 }
 
@@ -823,6 +868,10 @@ function generateTypeCheckExpr(
       return `typeof ${fieldPath} !== 'string'`
     case 'number':
       return `typeof ${fieldPath} !== 'number'`
+    case 'integer':
+      return `(typeof ${fieldPath} !== 'number' || !Number.isInteger(${fieldPath}))`
+    case 'non-negative-integer':
+      return `(typeof ${fieldPath} !== 'number' || !Number.isInteger(${fieldPath}) || ${fieldPath} < 0)`
     case 'boolean':
       return `typeof ${fieldPath} !== 'boolean'`
     case 'null':
@@ -1448,6 +1497,41 @@ function runAllTests(
             if (!__deepEqual(actual, expected)) {
               throw new Error('Expected ' + __format(expected) + ' but got ' + __format(actual))
             }
+          },
+          toContain(item) {
+            if (!Array.isArray(actual) || !actual.some(function(v) { return __deepEqual(v, item) })) {
+              throw new Error('Expected ' + __format(actual) + ' to contain ' + __format(item))
+            }
+          },
+          toBeTruthy() {
+            if (!actual) {
+              throw new Error('Expected ' + __format(actual) + ' to be truthy')
+            }
+          },
+          toBeFalsy() {
+            if (actual) {
+              throw new Error('Expected ' + __format(actual) + ' to be falsy')
+            }
+          },
+          toBeNull() {
+            if (actual !== null) {
+              throw new Error('Expected null but got ' + __format(actual))
+            }
+          },
+          toBeUndefined() {
+            if (actual !== undefined) {
+              throw new Error('Expected undefined but got ' + __format(actual))
+            }
+          },
+          toBeGreaterThan(n) {
+            if (!(actual > n)) {
+              throw new Error('Expected ' + __format(actual) + ' to be greater than ' + n)
+            }
+          },
+          toBeLessThan(n) {
+            if (!(actual < n)) {
+              throw new Error('Expected ' + __format(actual) + ' to be less than ' + n)
+            }
           }
         }
       }
@@ -1589,6 +1673,41 @@ function runTestBlocks(
                 if (!__deepEqual(actual, expected)) {
                   throw new Error('Expected ' + __format(expected) + ' but got ' + __format(actual))
                 }
+              },
+              toContain(item) {
+                if (!Array.isArray(actual) || !actual.some(function(v) { return __deepEqual(v, item) })) {
+                  throw new Error('Expected ' + __format(actual) + ' to contain ' + __format(item))
+                }
+              },
+              toBeTruthy() {
+                if (!actual) {
+                  throw new Error('Expected ' + __format(actual) + ' to be truthy')
+                }
+              },
+              toBeFalsy() {
+                if (actual) {
+                  throw new Error('Expected ' + __format(actual) + ' to be falsy')
+                }
+              },
+              toBeNull() {
+                if (actual !== null) {
+                  throw new Error('Expected null but got ' + __format(actual))
+                }
+              },
+              toBeUndefined() {
+                if (actual !== undefined) {
+                  throw new Error('Expected undefined but got ' + __format(actual))
+                }
+              },
+              toBeGreaterThan(n) {
+                if (!(actual > n)) {
+                  throw new Error('Expected ' + __format(actual) + ' to be greater than ' + n)
+                }
+              },
+              toBeLessThan(n) {
+                if (!(actual < n)) {
+                  throw new Error('Expected ' + __format(actual) + ' to be less than ' + n)
+                }
               }
             }
           }
@@ -1897,3 +2016,108 @@ function runSignatureTest(
     }
   }
 }
+
+/**
+ * Compile WASM blocks and generate bootstrap code that embeds the compiled bytes
+ * and instantiates them on load.
+ */
+function generateWasmBootstrap(blocks: import('../parser').WasmBlock[]): {
+  code: string
+  results: {
+    id: string
+    success: boolean
+    error?: string
+    byteLength?: number
+  }[]
+} {
+  const results: {
+    id: string
+    success: boolean
+    error?: string
+    byteLength?: number
+  }[] = []
+  const compiledBlocks: {
+    id: string
+    base64: string
+    captures: string[]
+    needsMemory: boolean
+    wat: string
+  }[] = []
+
+  for (const block of blocks) {
+    const result = compileToWasm(block)
+    if (result.success) {
+      // Convert bytes to base64 for embedding
+      const base64 = btoa(String.fromCharCode(...result.bytes))
+      compiledBlocks.push({
+        id: block.id,
+        base64,
+        captures: block.captures,
+        needsMemory: result.needsMemory ?? false,
+        wat: result.wat ?? '',
+      })
+      results.push({
+        id: block.id,
+        success: true,
+        byteLength: result.bytes.length,
+      })
+    } else {
+      results.push({
+        id: block.id,
+        success: false,
+        error: result.error,
+      })
+    }
+  }
+
+  if (compiledBlocks.length === 0) {
+    return { code: '', results }
+  }
+
+  // Generate WAT comments for each block
+  const watComments = compiledBlocks
+    .map((b) => {
+      const watLines = b.wat.split('\n').map((line) => ` * ${line}`)
+      return `/**\n * WASM: ${b.id}\n${watLines.join('\n')}\n */`
+    })
+    .join('\n')
+
+  // Generate self-contained bootstrap code
+  // This runs immediately and sets up globalThis.__tjs_wasm_N functions
+  const blockData = compiledBlocks
+    .map(
+      (b) =>
+        `{id:${JSON.stringify(b.id)},b64:${JSON.stringify(
+          b.base64
+        )},c:${JSON.stringify(b.captures)},m:${b.needsMemory}}`
+    )
+    .join(',')
+
+  const code = `${watComments}
+;(async()=>{
+const __wasmBlocks=[${blockData}];
+const __b64ToBytes=s=>{const b=atob(s),a=new Uint8Array(b.length);for(let i=0;i<b.length;i++)a[i]=b.charCodeAt(i);return a};
+const __parseType=c=>{const m=c.match(/^(\\w+)\\s*:\\s*(\\w+)$/);if(!m)return{n:c,t:'f64',a:false};const[,n,ts]=m;const at={Float32Array:'f32',Float64Array:'f64',Int32Array:'i32',Uint8Array:'i32'};if(at[ts])return{n,t:'i32',a:true,at:ts};return{n,t:'f64',a:false}};
+for(const{id,b64,c,m}of __wasmBlocks){
+  const bytes=__b64ToBytes(b64);
+  const params=c.map(__parseType);
+  const hasArrays=params.some(p=>p.a);
+  let mem;if(m)mem=new WebAssembly.Memory({initial:256});
+  const imp=mem?{env:{memory:mem}}:{};
+  const inst=await WebAssembly.instantiate(await WebAssembly.compile(bytes),imp);
+  const compute=inst.exports.compute;
+  if(!hasArrays){globalThis[id]=compute;continue}
+  globalThis[id]=function(...args){
+    const mv=new Uint8Array(mem.buffer);let off=0;const ptrs=[];
+    for(let i=0;i<params.length;i++){const p=params[i],a=args[i];
+      if(p.a&&a?.buffer){const ab=new Uint8Array(a.buffer,a.byteOffset,a.byteLength);mv.set(ab,off);ptrs.push(off);off+=ab.length;off=(off+7)&~7}
+      else ptrs.push(a)}
+    const r=compute(...ptrs);off=0;
+    for(let i=0;i<params.length;i++){const p=params[i],a=args[i];
+      if(p.a&&a?.buffer){const ab=new Uint8Array(a.buffer,a.byteOffset,a.byteLength);ab.set(mv.slice(off,off+ab.length));off+=ab.length;off=(off+7)&~7}}
+    return r};
+}})();
+`.trim()
+
+  return { code, results }
+}

package/src/lang/index.ts

@@ -90,10 +90,7 @@ export {
   instantiateWasm,
   registerWasmBlock,
   compileWasmBlocks,
-  compileWasmBlocksForIframe,
-  generateWasmInstantiationCode,
   type WasmCompileResult,
-  type CompiledWasmData,
 } from './wasm'
 export type { WasmBlock } from './parser'
 export {

package/src/lang/inference.ts

@@ -29,7 +29,13 @@ export function inferTypeFromValue(node: Expression): TypeDescriptor {
         return { kind: 'string' }
       }
       if (typeof value === 'number') {
-        return { kind: 'number' }
+        // Distinguish float vs integer by checking if source contains '.'
+        // 2.0 -> number (float), 42 -> integer
+        const raw = (node as any).raw as string | undefined
+        if (raw && raw.includes('.')) {
+          return { kind: 'number' }
+        }
+        return { kind: 'integer' }
       }
       if (typeof value === 'boolean') {
         return { kind: 'boolean' }
@@ -110,14 +116,26 @@ export function inferTypeFromValue(node: Expression): TypeDescriptor {
     }
 
     case 'UnaryExpression': {
-      // Handle negative numbers: -1
-      if (
-        (node as any).operator === '-' &&
-        (node as any).argument.type === 'Literal'
-      ) {
-        const value = (node as any).argument.value
+      const op = (node as any).operator
+      const arg = (node as any).argument
+
+      // +N means non-negative integer (e.g., +1, +3)
+      if (op === '+' && arg.type === 'Literal') {
+        const value = arg.value
         if (typeof value === 'number') {
-          return { kind: 'number' }
+          return { kind: 'non-negative-integer' }
+        }
+      }
+
+      // -N means integer or float depending on source
+      if (op === '-' && arg.type === 'Literal') {
+        const value = arg.value
+        if (typeof value === 'number') {
+          const raw = arg.raw as string | undefined
+          if (raw && raw.includes('.')) {
+            return { kind: 'number' }
+          }
+          return { kind: 'integer' }
         }
       }
       return { kind: 'any' }
@@ -258,6 +276,10 @@ export function extractLiteralValue(node: Expression): any {
         const arg = extractLiteralValue((node as any).argument)
         return typeof arg === 'number' ? -arg : undefined
       }
+      if ((node as any).operator === '+') {
+        const arg = extractLiteralValue((node as any).argument)
+        return typeof arg === 'number' ? +arg : undefined
+      }
       return undefined
 
     case 'LogicalExpression': {
@@ -310,6 +332,12 @@ export function typeToString(type: TypeDescriptor): string {
       return type.nullable ? 'string | null' : 'string'
     case 'number':
       return type.nullable ? 'number | null' : 'number'
+    case 'integer':
+      return type.nullable ? 'integer | null' : 'integer'
+    case 'non-negative-integer':
+      return type.nullable
+        ? 'non-negative integer | null'
+        : 'non-negative integer'
     case 'boolean':
       return type.nullable ? 'boolean | null' : 'boolean'
     case 'null':
@@ -354,6 +382,10 @@ export function checkType(value: any, type: TypeDescriptor): boolean {
       return typeof value === 'string'
     case 'number':
       return typeof value === 'number'
+    case 'integer':
+      return typeof value === 'number' && Number.isInteger(value)
+    case 'non-negative-integer':
+      return typeof value === 'number' && Number.isInteger(value) && value >= 0
     case 'boolean':
       return typeof value === 'boolean'
     case 'array':