tjs-lang 0.2.7 → 0.3.0

package/src/lang/wasm.ts

@@ -227,6 +227,16 @@ const Op = {
   i32_extend16_s: 0xc1,
 } as const
 
+/** Reverse lookup: opcode byte -> instruction name */
+const OpName: Record<number, string> = Object.fromEntries(
+  Object.entries(Op).map(([name, code]) => [code, name.replace(/_/g, '.')])
+)
+
+/** Emit WAT instruction to context */
+function wat(ctx: CompileContext, instruction: string): void {
+  ctx.wat.push('  '.repeat(ctx.watIndent) + instruction)
+}
+
 // ============================================================================
 // LEB128 Encoding
 // ============================================================================
@@ -286,6 +296,129 @@ function encodeVector(items: number[][]): number[] {
   return [...encodeULEB128(items.length), ...items.flat()]
 }
 
+// ============================================================================
+// Disassembly (for debugging)
+// ============================================================================
+
+/** Decode ULEB128 from bytes, return [value, bytesConsumed] */
+function decodeULEB128(bytes: number[], offset: number): [number, number] {
+  let result = 0
+  let shift = 0
+  let i = offset
+  while (i < bytes.length) {
+    const byte = bytes[i]
+    result |= (byte & 0x7f) << shift
+    i++
+    if ((byte & 0x80) === 0) break
+    shift += 7
+  }
+  return [result, i - offset]
+}
+
+/** Decode f64 from 8 bytes */
+function decodeF64(bytes: number[], offset: number): number {
+  const buffer = new ArrayBuffer(8)
+  const view = new Uint8Array(buffer)
+  for (let i = 0; i < 8; i++) view[i] = bytes[offset + i]
+  return new Float64Array(buffer)[0]
+}
+
+/** Disassemble function body bytes to WAT-like text */
+function disassemble(
+  code: number[],
+  params: TypedParam[],
+  localTypes: WasmValueType[]
+): string {
+  const lines: string[] = []
+  let indent = 1
+  const ind = () => '  '.repeat(indent)
+
+  // Function signature
+  const paramStr = params
+    .map((p, i) => `(param $${p.name} ${p.type})`)
+    .join(' ')
+  const localStr = localTypes
+    .map((t, i) => `(local $L${params.length + i} ${t})`)
+    .join(' ')
+  lines.push(`(func (export "compute") ${paramStr} (result f64)`)
+  if (localStr) lines.push(`  ${localStr}`)
+
+  let i = 0
+  while (i < code.length) {
+    const op = code[i]
+    const name = OpName[op] || `unknown(0x${op.toString(16)})`
+    i++
+
+    // Handle instructions with immediates
+    if (op === Op.local_get || op === Op.local_set || op === Op.local_tee) {
+      const [idx, len] = decodeULEB128(code, i)
+      i += len
+      const paramName =
+        idx < params.length ? `$${params[idx].name}` : `$L${idx}`
+      lines.push(`${ind()}${name} ${paramName}`)
+    } else if (op === Op.br || op === Op.br_if) {
+      const [depth, len] = decodeULEB128(code, i)
+      i += len
+      lines.push(`${ind()}${name} ${depth}`)
+    } else if (op === Op.i32_const) {
+      const [val, len] = decodeULEB128(code, i)
+      i += len
+      lines.push(`${ind()}i32.const ${val}`)
+    } else if (op === Op.f64_const) {
+      const val = decodeF64(code, i)
+      i += 8
+      lines.push(`${ind()}f64.const ${val}`)
+    } else if (op === Op.block || op === Op.loop) {
+      const blockType = code[i]
+      i++
+      lines.push(
+        `${ind()}${name}${
+          blockType === Type.void
+            ? ''
+            : ` (result ${blockType === Type.f64 ? 'f64' : 'i32'})`
+        }`
+      )
+      indent++
+    } else if (op === Op.if) {
+      const blockType = code[i]
+      i++
+      lines.push(
+        `${ind()}if${
+          blockType === Type.void
+            ? ''
+            : ` (result ${blockType === Type.f64 ? 'f64' : 'i32'})`
+        }`
+      )
+      indent++
+    } else if (op === Op.else) {
+      indent--
+      lines.push(`${ind()}else`)
+      indent++
+    } else if (op === Op.end) {
+      indent = Math.max(1, indent - 1)
+      lines.push(`${ind()}end`)
+    } else if (
+      op === Op.f64_load ||
+      op === Op.f64_store ||
+      op === Op.f32_load ||
+      op === Op.f32_store ||
+      op === Op.i32_load ||
+      op === Op.i32_store
+    ) {
+      const [align, len1] = decodeULEB128(code, i)
+      i += len1
+      const [offset, len2] = decodeULEB128(code, i)
+      i += len2
+      lines.push(`${ind()}${name}${offset ? ` offset=${offset}` : ''}`)
+    } else {
+      lines.push(`${ind()}${name}`)
+    }
+  }
+
+  lines.push(')')
+  return lines.join('\n')
+}
+
 // ============================================================================
 // Type System
 // ============================================================================
@@ -391,6 +524,10 @@ interface CompileContext {
   needsMemory: boolean
   /** Whether the function has a return statement */
   hasReturn: boolean
+  /** WAT text representation lines (for debugging) */
+  wat: string[]
+  /** Current indentation level for WAT */
+  watIndent: number
 }
 
 function createContext(params: TypedParam[]): CompileContext {
@@ -405,6 +542,8 @@ function createContext(params: TypedParam[]): CompileContext {
     needsMathImports: new Set(),
     needsMemory: false,
     hasReturn: false,
+    wat: [],
+    watIndent: 1,
   }
 
   // Add params to locals map
@@ -1613,11 +1752,15 @@ export function compileToWasm(block: WasmBlock): WasmCompileResult {
       ctx.hasReturn
     )
 
+    // Generate WAT disassembly for debugging
+    const watText = disassemble(code, params, ctx.localTypes)
+
     return {
       bytes: new Uint8Array(moduleBytes),
       warnings: ctx.warnings,
       success: true,
       needsMemory: ctx.needsMemory,
+      wat: watText,
     }
   } catch (e: any) {
     return {

package/src/types/Type.test.ts

@@ -137,6 +137,70 @@ describe('Type()', () => {
       expect(Email.check(Email.example)).toBe(true)
     })
   })
+
+  describe('Schema examples support', () => {
+    it('extracts examples from schema metadata', () => {
+      const Username = Type(
+        'username',
+        s.string.meta({ examples: ['alice', 'bob', 'charlie'] })
+      )
+
+      expect(Username.examples).toEqual(['alice', 'bob', 'charlie'])
+    })
+
+    it('sets example to first schema example when no explicit example given', () => {
+      const Username = Type(
+        'username',
+        s.string.meta({ examples: ['alice', 'bob'] })
+      )
+
+      expect(Username.example).toBe('alice')
+    })
+
+    it('preserves explicit example over schema examples', () => {
+      const Username = Type(
+        'username',
+        s.string.meta({ examples: ['alice', 'bob'] }),
+        'explicit_user'
+      )
+
+      expect(Username.example).toBe('explicit_user')
+      expect(Username.examples).toEqual(['alice', 'bob'])
+    })
+
+    it('has no examples when schema lacks metadata', () => {
+      const Name = Type('name', s.string)
+
+      expect(Name.examples).toBeUndefined()
+    })
+
+    it('has no examples for predicate-based types', () => {
+      const Even = Type(
+        'even number',
+        (n) => typeof n === 'number' && n % 2 === 0
+      )
+
+      expect(Even.examples).toBeUndefined()
+    })
+
+    it('has no examples for simple form', () => {
+      const Name = Type('name', 'Alice')
+
+      expect(Name.examples).toBeUndefined()
+      expect(Name.example).toBe('Alice')
+    })
+
+    it('validates using schema even with examples', () => {
+      const ShortString = Type(
+        'short string',
+        s.string.max(5).meta({ examples: ['hi', 'hey'] })
+      )
+
+      expect(ShortString.check('hi')).toBe(true)
+      expect(ShortString.check('toolong')).toBe(false)
+      expect(ShortString.examples).toEqual(['hi', 'hey'])
+    })
+  })
 })
 
 describe('Built-in Types', () => {

package/src/types/Type.ts

@@ -40,8 +40,10 @@ export interface RuntimeType<T = unknown> {
   readonly schema?: Schema
   /** The predicate function (if predicate-based) */
   readonly predicate?: (value: unknown) => boolean
-  /** Example value (for documentation and implicit testing) */
+  /** Example value (for documentation and signature testing) */
   readonly example?: T
+  /** Multiple example values (from schema metadata, for autocomplete hints) */
+  readonly examples?: T[]
   /** Default value (for instantiation) */
   readonly default?: T
   /** Brand for type identification */
@@ -150,6 +152,24 @@ export function Type<T = unknown>(
     description = schemaToDescription(schema)
   }
 
+  // Extract examples from schema metadata (if any)
+  let examples: T[] | undefined
+  if (schema) {
+    const jsonSchema = (schema as any)?.schema ?? schema
+    if (
+      jsonSchema &&
+      typeof jsonSchema === 'object' &&
+      Array.isArray((jsonSchema as any).examples)
+    ) {
+      examples = (jsonSchema as any).examples as T[]
+    }
+  }
+
+  // If no explicit example was provided, use first schema example for autocomplete
+  if (example === undefined && examples && examples.length > 0) {
+    example = examples[0]
+  }
+
   // Build the check function
   const check = (value: unknown): value is T => {
     if (predicate) {
@@ -167,6 +187,7 @@ export function Type<T = unknown>(
     schema,
     predicate,
     example,
+    examples,
     default: defaultValue,
     __runtimeType: true as const,
   }

package/src/use-cases/transpiler-integration.test.ts

@@ -134,7 +134,7 @@ describe('Transpiler Integration', () => {
       expect(signature.parameters.query.type.kind).toBe('string')
       expect(signature.parameters.query.required).toBe(true)
       expect(signature.parameters.query.description).toBe('Search terms')
-      expect(signature.parameters.limit.type.kind).toBe('number')
+      expect(signature.parameters.limit.type.kind).toBe('integer')
       expect(signature.parameters.limit.required).toBe(false)
       expect(signature.parameters.limit.default).toBe(10)
       expect(signature.parameters.limit.description).toBe('Max results')
@@ -153,7 +153,7 @@ describe('Transpiler Integration', () => {
       expect(signature.parameters.user.type.kind).toBe('object')
       expect(signature.parameters.user.type.shape?.name.kind).toBe('string')
       expect(signature.parameters.user.type.shape?.email.kind).toBe('string')
-      expect(signature.parameters.user.type.shape?.age.kind).toBe('number')
+      expect(signature.parameters.user.type.shape?.age.kind).toBe('integer')
       expect(signature.parameters.user.required).toBe(true)
 
       expect(signature.parameters.options.type.kind).toBe('object')
@@ -383,16 +383,16 @@ describe('Transpiler Integration', () => {
           let answer = ''
           let valid = false
           let tries = 0
-          
+
           while (!valid && tries < 3) {
             answer = llmPredict({ prompt: question })
             tries = tries + 1
-            
+
             if (answer == 'A' || answer == 'B' || answer == 'C' || answer == 'D') {
               valid = true
             }
           }
-          
+
           return { answer, tries, valid }
         }
       `)
@@ -772,9 +772,9 @@ describe('Transpiler Integration', () => {
       const ast = ajs(`
         function test() {
           let d = Date('2024-06-15T10:30:00Z')
-          return { 
-            year: d.year, 
-            month: d.month, 
+          return {
+            year: d.year,
+            month: d.month,
             day: d.day,
             hours: d.hours,
             minutes: d.minutes
@@ -826,7 +826,7 @@ describe('Transpiler Integration', () => {
       const ast = ajs(`
         function test() {
           let d = Date('2024-06-15T14:30:45Z')
-          return { 
+          return {
             iso: d.format('ISO'),
             date: d.format('date'),
             custom: d.format('YYYY-MM-DD')
@@ -847,7 +847,7 @@ describe('Transpiler Integration', () => {
         function test() {
           let a = Date('2024-01-15')
           let b = Date('2024-01-20')
-          return { 
+          return {
             aBeforeB: a.isBefore(b),
             aAfterB: a.isAfter(b)
           }

package/src/vm/atoms/batteries.ts

@@ -145,6 +145,7 @@ export const llmPredictBattery = defineAtom(
     responseFormat: s.any.optional,
   }),
   s.object({
+    role: s.string.optional,
     content: s.string.optional,
     tool_calls: s.array(s.any).optional,
   }),
@@ -189,6 +190,7 @@ export const llmVision = defineAtom(
     responseFormat: s.any.optional,
   }),
   s.object({
+    role: s.string.optional,
     content: s.string.optional,
     tool_calls: s.array(s.any).optional,
   }),