tjs-lang 0.7.6 → 0.7.8

package/src/lang/parser.ts

@@ -51,11 +51,58 @@ import {
   transformConstBang,
   transformBangAccess,
   transformExtensionCalls,
+  transformLetTypeAnnotations,
 } from './parser-transforms'
 
 // Re-export transformExtensionCalls for js.ts
 export { transformExtensionCalls } from './parser-transforms'
 
+/**
+ * Strip single-line comments (//) from source.
+ * Replaces comment content with spaces to preserve character offsets.
+ * Skips // inside strings and block comments.
+ */
+export function stripLineComments(source: string): string {
+  let result = ''
+  let i = 0
+  while (i < source.length) {
+    const ch = source[i]
+    // String literals — skip to closing quote
+    if (ch === "'" || ch === '"' || ch === '`') {
+      const quote = ch
+      result += ch
+      i++
+      while (i < source.length && source[i] !== quote) {
+        if (source[i] === '\\') {
+          result += source[i++]
+        }
+        if (i < source.length) result += source[i++]
+      }
+      if (i < source.length) result += source[i++] // closing quote
+      continue
+    }
+    // Block comment — pass through (may contain //)
+    if (ch === '/' && source[i + 1] === '*') {
+      const end = source.indexOf('*/', i + 2)
+      const slice = end === -1 ? source.slice(i) : source.slice(i, end + 2)
+      result += slice
+      i += slice.length
+      continue
+    }
+    // Line comment — replace with spaces to preserve offsets
+    if (ch === '/' && source[i + 1] === '/') {
+      const nl = source.indexOf('\n', i)
+      const end = nl === -1 ? source.length : nl
+      result += ' '.repeat(end - i)
+      i = end // leave \n for next iteration
+      continue
+    }
+    result += ch
+    i++
+  }
+  return result
+}
+
 export function preprocess(
   source: string,
   options: PreprocessOptions = {}
@@ -74,6 +121,7 @@ export function preprocess(
   testErrors: string[]
   polymorphicNames: Set<string>
   extensions: Map<string, Set<string>>
+  letAnnotations: Map<string, string>
 } {
   const originalSource = source
   let moduleSafety: 'none' | 'inputs' | 'all' | undefined
@@ -97,6 +145,7 @@ export function preprocess(
         tjsStandard: false,
         tjsSafeEval: false,
         tjsNoVar: false,
+        tjsSafeAssign: false,
       }
     : {
         tjsEquals: true,
@@ -106,6 +155,7 @@ export function preprocess(
         tjsStandard: true,
         tjsSafeEval: false, // opt-in only (adds import)
         tjsNoVar: true,
+        tjsSafeAssign: true,
       }
 
   // Safety: native TJS defaults to 'inputs' (runtime default),
@@ -134,7 +184,7 @@ export function preprocess(
   // TjsCompat disables all TJS modes (useful for native TJS opting out)
   // Individual modes: TjsEquals, TjsClass, TjsDate, TjsNoeval, TjsStandard, TjsSafeEval
   const directivePattern =
-    /^(\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*)*)\s*(TjsStrict|TjsCompat|TjsEquals|TjsClass|TjsDate|TjsNoeval|TjsNoVar|TjsStandard|TjsSafeEval)\b/
+    /^(\s*(?:\/\/[^\n]*\n|\/\*[\s\S]*?\*\/\s*)*)\s*(TjsStrict|TjsCompat|TjsEquals|TjsClass|TjsDate|TjsNoeval|TjsNoVar|TjsStandard|TjsSafeEval|TjsSafeAssign)\b/
 
   let match
   while ((match = source.match(directivePattern))) {
@@ -148,6 +198,7 @@ export function preprocess(
       tjsModes.tjsNoeval = true
       tjsModes.tjsNoVar = true
       tjsModes.tjsStandard = true
+      tjsModes.tjsSafeAssign = true
     } else if (directive === 'TjsCompat') {
       // Disable all TJS modes (JS-compatible)
       tjsModes.tjsEquals = false
@@ -157,6 +208,7 @@ export function preprocess(
       tjsModes.tjsNoVar = false
       tjsModes.tjsStandard = false
       tjsModes.tjsSafeEval = false
+      tjsModes.tjsSafeAssign = false
     } else if (directive === 'TjsEquals') {
       tjsModes.tjsEquals = true
     } else if (directive === 'TjsClass') {
@@ -171,6 +223,8 @@ export function preprocess(
       tjsModes.tjsStandard = true
     } else if (directive === 'TjsSafeEval') {
       tjsModes.tjsSafeEval = true
+    } else if (directive === 'TjsSafeAssign') {
+      tjsModes.tjsSafeAssign = true
     }
 
     // Remove the directive from source
@@ -182,6 +236,11 @@ export function preprocess(
     )
   }
 
+  // Strip single-line comments early — they confuse brace matching,
+  // ASI protection, and test extraction (e.g. apostrophes in comments)
+  // Preserves line structure by keeping the newline
+  source = stripLineComments(source)
+
   // TjsStandard mode: insert semicolons to prevent ASI footguns
   // Must happen early before other transformations modify line structure
   if (tjsModes.tjsStandard) {
@@ -196,6 +255,13 @@ export function preprocess(
   // Must happen before acorn parsing since !. is not valid JS
   source = transformBangAccess(source)
 
+  // Transform `let x: <example>` declarations: strip annotation and record
+  // varName -> example. Must happen before paren transforms so the colon
+  // is not confused with TS-style annotations on params/returns.
+  const letAnnoResult = transformLetTypeAnnotations(source)
+  source = letAnnoResult.source
+  const letAnnotations = letAnnoResult.annotations
+
   // Transform Is/IsNot infix operators to function calls
   // a Is b -> Is(a, b)
   // a IsNot b -> IsNot(a, b)
@@ -320,6 +386,7 @@ export function preprocess(
     testErrors: testResult.errors,
     polymorphicNames: polyResult.polymorphicNames,
     extensions: extResult.extensions,
+    letAnnotations,
   }
 }
 
@@ -341,6 +408,8 @@ export function parse(
   wasmBlocks: WasmBlock[]
   tests: TestBlock[]
   testErrors: string[]
+  letAnnotations: Map<string, string>
+  tjsModes: TjsModes
 } {
   const {
     filename = '<source>',
@@ -361,6 +430,8 @@ export function parse(
     wasmBlocks,
     tests,
     testErrors,
+    letAnnotations,
+    tjsModes,
   } = colonShorthand
     ? preprocess(source, { vmTarget })
     : {
@@ -375,6 +446,17 @@ export function parse(
         wasmBlocks: [] as WasmBlock[],
         tests: [] as TestBlock[],
         testErrors: [] as string[],
+        letAnnotations: new Map<string, string>(),
+        tjsModes: {
+          tjsEquals: false,
+          tjsClass: false,
+          tjsDate: false,
+          tjsNoeval: false,
+          tjsStandard: false,
+          tjsSafeEval: false,
+          tjsNoVar: false,
+          tjsSafeAssign: false,
+        } as TjsModes,
       }
 
   try {
@@ -397,6 +479,8 @@ export function parse(
       wasmBlocks,
       tests,
       testErrors,
+      letAnnotations,
+      tjsModes,
     }
   } catch (e: any) {
     // Convert Acorn error to our error type

package/src/lang/runtime.ts

@@ -605,6 +605,26 @@ export function TypeOf(value: unknown): string {
   return typeof value
 }
 
+/**
+ * Honest boolean coercion. Like `Boolean(x)` but unwraps boxed primitives
+ * first, fixing the JS footgun `Boolean(new Boolean(false)) === true`.
+ *
+ * Under TjsStandard, the source rewriter wraps every truthiness context
+ * (if/while/for/do-while conditions, `!`, `&&`, `||`, ternary, and
+ * top-level `Boolean(x)` calls) with this function so a boxed `false`
+ * actually behaves as `false`.
+ */
+export function toBool(value: unknown): boolean {
+  if (
+    value instanceof Boolean ||
+    value instanceof Number ||
+    value instanceof String
+  ) {
+    return Boolean((value as any).valueOf())
+  }
+  return Boolean(value)
+}
+
 export function Eq(a: unknown, b: unknown): boolean {
   // Unwrap boxed primitives
   if (a instanceof String || a instanceof Number || a instanceof Boolean) {
@@ -844,6 +864,78 @@ type TypeSpec =
   | string
   | { check: (v: unknown) => boolean | string; description: string }
 
+/**
+ * Check that a passed-in function's declared shape matches the expected
+ * shape. Returns the function unchanged on a match, or a MonadicError on
+ * mismatch. Untyped functions (no `__tjs` metadata — anonymous arrows
+ * like `x => false`) pass through unchanged on the assumption that the
+ * caller knows what they're doing; they accept any args and return
+ * whatever they return.
+ *
+ * This is a ONE-SHOT check at pass time, NOT a per-call wrapper. The TJS
+ * design call: a wrong-shape callback is ONE error at the boundary, not
+ * N errors when the receiving function invokes the callback N times.
+ *
+ * Compatibility rules (deliberately permissive — strict subtyping is a
+ * separate, larger feature):
+ *   - For each expected param: the actual function may declare fewer
+ *     params (extras simply not used). If both declare a kind, they
+ *     must match exactly. Either side being `any` always matches.
+ *   - For the return type: same exact-match rule when both are known.
+ */
+export function checkFnShape(
+  fn: unknown,
+  expectedParamKinds: string[],
+  expectedReturnKind: string,
+  path: string
+): unknown {
+  if (typeof fn !== 'function') return fn // outer "is callable" check already ran
+  const meta = (fn as any).__tjs
+  if (!meta || !meta.params) return fn // untyped — let it run
+
+  const actualEntries = Object.entries(meta.params) as Array<
+    [string, { type?: { kind?: string } }]
+  >
+  for (let i = 0; i < expectedParamKinds.length; i++) {
+    const expectedKind = expectedParamKinds[i]
+    if (expectedKind === 'any') continue
+    const actual = actualEntries[i]
+    if (!actual) continue // function takes fewer params, OK
+    const actualKind = actual[1]?.type?.kind
+    if (!actualKind || actualKind === 'any') continue
+    if (actualKind !== expectedKind) {
+      return new MonadicError(
+        `Expected (...arg${i}: ${expectedKind}, ...) for '${path}', ` +
+          `but callback declares arg${i} as ${actualKind}`,
+        `${path}(arg${i})`,
+        expectedKind,
+        actualKind
+      )
+    }
+  }
+
+  if (expectedReturnKind !== 'any' && meta.returns) {
+    // Metadata's `returns` is `{ type: TypeDescriptor, defaults?: ... }`,
+    // but defensively also accept a bare TypeDescriptor.
+    const actualReturnKind = meta.returns.type?.kind ?? meta.returns.kind
+    if (
+      actualReturnKind &&
+      actualReturnKind !== 'any' &&
+      actualReturnKind !== expectedReturnKind
+    ) {
+      return new MonadicError(
+        `Expected callback returning ${expectedReturnKind} for '${path}', ` +
+          `but callback returns ${actualReturnKind}`,
+        `${path}(return)`,
+        expectedReturnKind,
+        actualReturnKind
+      )
+    }
+  }
+
+  return fn
+}
+
 /** Parameter metadata with optional location */
 interface ParamMeta {
   type: TypeSpec
@@ -1478,6 +1570,7 @@ export function createRuntime() {
     checkType,
     validateArgs,
     wrap,
+    checkFnShape,
     wrapClass,
     compareVersions,
     versionsCompatible,
@@ -1528,6 +1621,8 @@ export function createRuntime() {
     NotEq,
     // Honest typeof (typeof with TjsEquals)
     TypeOf,
+    // Honest truthiness (unwraps boxed primitives)
+    toBool,
     tjsEquals,
     // Extensions
     registerExtension: instanceRegisterExtension,
@@ -1559,6 +1654,7 @@ export const runtime = {
   checkType,
   validateArgs,
   wrap,
+  checkFnShape,
   wrapClass,
   compareVersions,
   versionsCompatible,
@@ -1612,6 +1708,8 @@ export const runtime = {
   NotEq,
   // Honest typeof (used by typeof with TjsEquals)
   TypeOf,
+  // Honest truthiness (used in TjsStandard for boxed-primitive coercion)
+  toBool,
 }
 
 /**

package/src/lang/tests.ts

@@ -106,15 +106,17 @@ function extractEmbeddedTests(source: string): ExtractedTest[] {
   const tests: ExtractedTest[] = []
 
   // Match: /*test 'description' { ... }*/  or  /*test { ... }*/
+  // Each quote type gets its own alternative so the description can contain
+  // the other quote types (e.g. `test 'typeof null is "null"' {`).
   const embeddedRegex =
-    /\/\*test\s+(['"`])([^'"`]*)\1\s*\{([\s\S]*?)\}\s*\*\/|\/\*test\s*\{([\s\S]*?)\}\s*\*\//g
+    /\/\*test\s+'([^']*)'\s*\{([\s\S]*?)\}\s*\*\/|\/\*test\s+"([^"]*)"\s*\{([\s\S]*?)\}\s*\*\/|\/\*test\s+`([^`]*)`\s*\{([\s\S]*?)\}\s*\*\/|\/\*test\s*\{([\s\S]*?)\}\s*\*\//g
 
   let match
   while ((match = embeddedRegex.exec(source)) !== null) {
-    // Group 2 = description for quoted, group 3 = body for quoted
-    // Group 4 = body for anonymous
-    const desc = match[2] || `embedded test ${tests.length + 1}`
-    const body = (match[3] || match[4] || '').trim()
+    // Groups: 1/3/5 = description for ' " ` ; 2/4/6 = body for ' " ` ; 7 = body for anonymous
+    const desc =
+      match[1] || match[3] || match[5] || `embedded test ${tests.length + 1}`
+    const body = (match[2] || match[4] || match[6] || match[7] || '').trim()
 
     tests.push({
       description: desc,
@@ -145,8 +147,10 @@ export function extractTests(source: string): TestExtractionResult {
   //   test { ... }                   (anonymous test)
   //   test 'description' { ... }     (canonical TJS)
   //   test('description') { ... }    (also valid - parenthesized string is still a string)
+  // Each quote type has its own alternative so the description can contain
+  // the other quote types (e.g. `test 'typeof null is "null"' {`).
   const testRegex =
-    /test\s+(['"`])([^'"`]*)\1\s*\{|test\s*\(\s*(['"`])([^'"`]*)\3\s*\)\s*\{|test\s*\{/g
+    /test\s+'([^']*)'\s*\{|test\s+"([^"]*)"\s*\{|test\s+`([^`]*)`\s*\{|test\s*\(\s*'([^']*)'\s*\)\s*\{|test\s*\(\s*"([^"]*)"\s*\)\s*\{|test\s*\(\s*`([^`]*)`\s*\)\s*\{|test\s*\{/g
   const mockRegex = /mock\s*\{/g
 
   let cleanCode = source
@@ -164,8 +168,17 @@ export function extractTests(source: string): TestExtractionResult {
       continue
     }
 
-    // Description is in group 2 for `test 'desc'`, group 4 for `test('desc')`, or undefined for `test {`
-    const desc = match[2] || match[4] || `test ${tests.length + 1}`
+    // Groups 1/2/3 = `test 'desc'` / `test "desc"` / `test \`desc\``
+    // Groups 4/5/6 = parenthesized variants
+    // No group when description is omitted
+    const desc =
+      match[1] ||
+      match[2] ||
+      match[3] ||
+      match[4] ||
+      match[5] ||
+      match[6] ||
+      `test ${tests.length + 1}`
     const bodyStart = match.index + match[0].length
 
     // Find matching closing brace

package/src/lang/types.ts

@@ -22,6 +22,7 @@ export interface TypeDescriptor {
     | 'array'
     | 'object'
     | 'union'
+    | 'function'
     | 'any'
   nullable?: boolean
   /** For arrays: the element type */
@@ -32,6 +33,11 @@ export interface TypeDescriptor {
   members?: TypeDescriptor[]
   /** For destructured parameters: full parameter descriptors */
   destructuredParams?: Record<string, ParameterDescriptor>
+  /** For functions: declared parameters with names and inferred types */
+  params?: Array<{ name: string; type: TypeDescriptor }>
+  /** For functions: inferred return type. Concise arrow bodies infer from
+   * the expression; block bodies and complex expressions stay `any`. */
+  returns?: TypeDescriptor
 }
 
 /** Describes a function parameter */

package/src/rbac/index.ts

@@ -46,7 +46,7 @@ export {
   interpretRuleResult,
   hasRoleLevel,
   buildRuleContext,
-} from './rules.js'
+} from './rules.tjs'
 
 /**
  * Security rule definition
@@ -125,7 +125,7 @@ import {
   validateSchema,
   buildRuleContext,
   interpretRuleResult,
-} from './rules.js'
+} from './rules.tjs'
 
 /**
  * Create an RBAC instance with a store backend

package/src/rbac/rules.tjs.d.ts

@@ -0,0 +1,9 @@
+// Ambient declarations for rules.tjs. The bun plugin (bunfig.toml)
+// transpiles .tjs at runtime; tsc needs explicit names to resolve the
+// `from './rules.tjs'` imports in index.ts.
+export function evaluateAccessShortcut(accessRule: any, context: any): any
+export function selectAccessRule(rule: any, context: any): any
+export function validateSchema(schema: any, data: any): any
+export function interpretRuleResult(result: any): any
+export function hasRoleLevel(userRoles: any, requiredRole: any): any
+export function buildRuleContext(options: any): any

package/src/vm/atoms/batteries.ts

@@ -25,7 +25,7 @@ interface StoreBattery {
 interface LLMBattery {
   predict(
     system: string,
-    user: string,
+    user: string | any[], // string for single-turn, message array for multi-turn
     tools?: any[],
     responseFormat?: any
   ): Promise<any>
@@ -140,7 +140,7 @@ export const llmPredictBattery = defineAtom(
   'llmPredictBattery',
   s.object({
     system: s.string.optional,
-    user: s.string,
+    user: s.union([s.string, s.array(s.any)]), // string or message array for multi-turn
     tools: s.array(s.any).optional,
     responseFormat: s.any.optional,
   }),

package/src/vm/runtime.ts

@@ -451,7 +451,9 @@ export type ExprNode =
   | {
       $expr: 'member'
       object: ExprNode
-      property: string
+      // string for static `obj.foo` and literal-indexed `arr[0]`;
+      // ExprNode for variable-indexed `arr[i]` (evaluated at runtime).
+      property: string | ExprNode
       computed?: boolean
       optional?: boolean
     }
@@ -1132,8 +1134,12 @@ export function evaluateExpr(node: ExprNode, ctx: RuntimeContext): any {
         return undefined
       }
 
-      const prop = node.property
-      assertSafeProperty(prop)
+      // Property is either a static string or a computed expression node (e.g. arr[i])
+      const prop =
+        typeof node.property === 'object' && node.property !== null
+          ? evaluateExpr(node.property, ctx)
+          : node.property
+      assertSafeProperty(String(prop))
 
       return obj?.[prop]
     }
@@ -1524,6 +1530,7 @@ export const whileLoop = defineAtom(
       if ((ctx.fuel.current -= 0.1) <= 0) throw new Error('Out of Fuel')
       await seq.exec({ op: 'seq', steps: step.body } as any, ctx)
       if (ctx.output !== undefined) return
+      if (ctx.error) return // Propagate monadic errors out of the loop
     }
   },
   { docs: 'While Loop', timeoutMs: 0, cost: 0.1 }

package/dist/src/rbac/rules.d.ts

@@ -1,184 +0,0 @@
-export function evaluateAccessShortcut(accessRule: any, context: any): {
-    allowed: boolean;
-    reason: string;
-} | {
-    allowed: boolean;
-    reason?: undefined;
-} | null;
-export namespace evaluateAccessShortcut {
-    namespace __tjs {
-        namespace params {
-            namespace accessRule {
-                namespace type {
-                    let kind: string;
-                }
-                let required: boolean;
-            }
-            namespace context {
-                export namespace type_1 {
-                    let kind_1: string;
-                    export { kind_1 as kind };
-                }
-                export { type_1 as type };
-                let required_1: boolean;
-                export { required_1 as required };
-            }
-        }
-        let unsafe: boolean;
-        let source: string;
-    }
-}
-export function selectAccessRule(rule: any, context: any): any;
-export namespace selectAccessRule {
-    export namespace __tjs_1 {
-        export namespace params_1 {
-            export namespace rule {
-                export namespace type_2 {
-                    let kind_2: string;
-                    export { kind_2 as kind };
-                }
-                export { type_2 as type };
-                let required_2: boolean;
-                export { required_2 as required };
-            }
-            export namespace context_1 {
-                export namespace type_3 {
-                    let kind_3: string;
-                    export { kind_3 as kind };
-                }
-                export { type_3 as type };
-                let required_3: boolean;
-                export { required_3 as required };
-            }
-            export { context_1 as context };
-        }
-        export { params_1 as params };
-        let unsafe_1: boolean;
-        export { unsafe_1 as unsafe };
-        let source_1: string;
-        export { source_1 as source };
-    }
-    export { __tjs_1 as __tjs };
-}
-export function validateSchema(schema: any, data: any): {
-    valid: boolean;
-    errors: string[];
-};
-export namespace validateSchema {
-    export namespace __tjs_2 {
-        export namespace params_2 {
-            namespace schema {
-                export namespace type_4 {
-                    let kind_4: string;
-                    export { kind_4 as kind };
-                }
-                export { type_4 as type };
-                let required_4: boolean;
-                export { required_4 as required };
-            }
-            namespace data {
-                export namespace type_5 {
-                    let kind_5: string;
-                    export { kind_5 as kind };
-                }
-                export { type_5 as type };
-                let required_5: boolean;
-                export { required_5 as required };
-            }
-        }
-        export { params_2 as params };
-        let unsafe_2: boolean;
-        export { unsafe_2 as unsafe };
-        let source_2: string;
-        export { source_2 as source };
-    }
-    export { __tjs_2 as __tjs };
-}
-export function interpretRuleResult(result: any): {
-    allowed: boolean;
-    reason: any;
-};
-export namespace interpretRuleResult {
-    export namespace __tjs_3 {
-        export namespace params_3 {
-            namespace result {
-                export namespace type_6 {
-                    let kind_6: string;
-                    export { kind_6 as kind };
-                }
-                export { type_6 as type };
-                let required_6: boolean;
-                export { required_6 as required };
-            }
-        }
-        export { params_3 as params };
-        let unsafe_3: boolean;
-        export { unsafe_3 as unsafe };
-        let source_3: string;
-        export { source_3 as source };
-    }
-    export { __tjs_3 as __tjs };
-}
-export function hasRoleLevel(userRoles: any, requiredRole: any): boolean;
-export namespace hasRoleLevel {
-    export namespace __tjs_4 {
-        export namespace params_4 {
-            namespace userRoles {
-                export namespace type_7 {
-                    let kind_7: string;
-                    export { kind_7 as kind };
-                }
-                export { type_7 as type };
-                let required_7: boolean;
-                export { required_7 as required };
-            }
-            namespace requiredRole {
-                export namespace type_8 {
-                    let kind_8: string;
-                    export { kind_8 as kind };
-                }
-                export { type_8 as type };
-                let required_8: boolean;
-                export { required_8 as required };
-            }
-        }
-        export { params_4 as params };
-        let unsafe_4: boolean;
-        export { unsafe_4 as unsafe };
-        let source_4: string;
-        export { source_4 as source };
-    }
-    export { __tjs_4 as __tjs };
-}
-export function buildRuleContext(options: any): {
-    _uid: any;
-    _roles: any;
-    _isAdmin: any;
-    _isAuthor: any;
-    _method: any;
-    _collection: any;
-    _docId: any;
-    doc: any;
-    newData: any;
-};
-export namespace buildRuleContext {
-    export namespace __tjs_5 {
-        export namespace params_5 {
-            namespace options {
-                export namespace type_9 {
-                    let kind_9: string;
-                    export { kind_9 as kind };
-                }
-                export { type_9 as type };
-                let required_9: boolean;
-                export { required_9 as required };
-            }
-        }
-        export { params_5 as params };
-        let unsafe_5: boolean;
-        export { unsafe_5 as unsafe };
-        let source_5: string;
-        export { source_5 as source };
-    }
-    export { __tjs_5 as __tjs };
-}