tjs-lang 0.8.2 → 0.8.4

package/CLAUDE.md

@@ -86,6 +86,8 @@ bun run functions:serve     # Local functions emulator
 - `src/lang/inference.ts` - Type inference from example values
 - `src/lang/json-schema.ts` - JSON Schema generation from TypeDescriptors and example values
 - `src/lang/linter.ts` - Static analysis (unused vars, unreachable code, no-explicit-new)
+- `src/lang/predicate.ts` - Predicate-safety verifier: certifies a cluster of pure, synchronous, composable predicates (reads the atom `effects` tag via `effectfulFromAtoms`); verified predicates compile to native JS. Also `suggest()` — mines a cluster for autocomplete completions (keyword sets → `value`s, `startsWith` guards → open-ended `stub`s like `var(--`; mined values run through the compiled predicate so they're guaranteed valid). Exported from `tjs-lang/lang`. See `experiments/predicates/` (CSS torture set + perf + suggest demo)
+- `src/lang/predicate-schema.ts` - Predicate-aware JSON-Schema: the `$predicate` keyword (computational types). `compilePredicateSchema`/`validatePredicateSchema` — structure for naive validators, `$predicate` for aware ones (progressive enhancement). The serializable-into-JSON-Schema endgame; exported from `tjs-lang/lang`
 - `src/lang/runtime.ts` - TJS runtime (monadic errors, type checking, wrapClass)
 - `src/lang/wasm.ts` - WASM compiler (opcodes, disassembler, bytecode generation; multi-function module composition; wasm-to-wasm `call <index>` resolution)
 - `src/lang/emitters/js-wasm.ts` - JS bootstrap emitter for compiled wasm modules (one `WebAssembly.compile` per file, name→export-index table, type-aware wrappers)
@@ -264,7 +266,7 @@ Coverage targets: 98% lines on `src/vm/runtime.ts` (security-critical), 80%+ ove
 
 ### Adding a New Atom
 
-1. Define with `defineAtom(opCode, inputSchema, outputSchema, implementation, { cost, timeoutMs, docs })`
+1. Define with `defineAtom(opCode, inputSchema, outputSchema, implementation, { cost, timeoutMs, docs, effects })`
 2. Add to `src/vm/atoms/` and export from `src/vm/atoms/index.ts`
 3. Add tests
 4. Run `bun run test:fast`
@@ -274,6 +276,7 @@ Coverage targets: 98% lines on `src/vm/runtime.ts` (security-critical), 80%+ ove
 - `cost` can be static number or dynamic: `(input, ctx) => number`
 - `timeoutMs` defaults to 1000ms; use `0` for no timeout (e.g., `seq`)
 - Atoms are always async; fuel deduction is automatic in the `exec` wrapper
+- `effects` defaults to `'pure'`; **set `'io'` for any atom that touches `ctx.capabilities` (fetch/store/llm/agent/code), is nondeterministic (random/uuid), or has side effects (console)**. This drives predicate-safety (a predicate may only call pure atoms — see `experiments/predicates/`). Core IO atoms are tagged centrally via `EFFECTFUL_CORE_OPS` in `runtime.ts`; the invariant is guarded by `src/vm/atom-effects.test.ts`.
 
 ### Debugging Agents
 
@@ -311,7 +314,7 @@ Full syntax documentation is in [`CLAUDE-TJS-SYNTAX.md`](CLAUDE-TJS-SYNTAX.md).
 - **Bang access**: `x!.foo` — returns MonadicError if `x` is null/undefined, otherwise bare `x.foo`. Chains propagate: `x!.foo!.bar`.
 - **Type/Generic/FunctionPredicate**: Three declaration forms for runtime type predicates
 - **`const!`**: Compile-time immutability, zero runtime cost
-- **Equality**: `==`/`!=` = structural equality by default in native TJS (via `Is`/`IsNot`), `===`/`!==` = identity
+- **Equality**: `==`/`!=` in native TJS (via `Eq`/`NotEq` under `TjsEquals`) are **footgun-free `===`** — they unwrap boxed primitives (`new Boolean(false) == false`) and treat `null`/`undefined` as equal, but do **NOT** coerce types (`'5' != 5`, `'' != false`) and are **NOT structural** (distinct objects/arrays are distinct: `{a:1} != {a:1}` — a real distinction, and structural `==` would be a silent O(n) hit). For deep structural comparison use the `Is`/`IsNot` function (or a type's `.Equals` hook). `===`/`!==` = strict identity.
 - **Polymorphic functions**: Multiple same-name declarations merge into arity/type dispatcher
 - **`extend` blocks**: Local class extensions without prototype pollution
 - **WASM blocks**: Inline WebAssembly compiled at transpile time, with SIMD intrinsics and `wasmBuffer()` zero-copy arrays

package/demo/autocomplete.test.ts

@@ -40,6 +40,43 @@ describe('getCompletions', () => {
     })
   })
 
+  describe('destructured bindings (scope-aware)', () => {
+    // Regression: the old regex `const NAME =` extractor missed all
+    // destructuring, so the tosijs todo example suggested nothing.
+    const todo = `import { elements, tosi } from 'tosijs'
+const { todoApp } = tosi({ todoApp: { items: [], newItem: '' } })
+const { h1, ul, template, li, label, input, button } = elements
+`
+
+    it('suggests destructured locals (todoApp, h1, button)', () => {
+      const completions = getCompletions({
+        source: todo,
+        position: todo.length,
+      })
+      const labels = completions.map((c) => c.label)
+      expect(labels).toContain('todoApp')
+      expect(labels).toContain('h1')
+      expect(labels).toContain('button')
+    })
+
+    it('shows where a destructured binding came from', () => {
+      const completions = getCompletions({
+        source: todo,
+        position: todo.length,
+      })
+      expect(completions.find((c) => c.label === 'h1')?.detail).toBe(
+        '∈ elements'
+      )
+    })
+
+    it('filters destructured locals by prefix', () => {
+      const src = todo + 'tod'
+      const completions = getCompletions({ source: src, position: src.length })
+      expect(completions.map((c) => c.label)).toContain('todoApp')
+      expect(completions.every((c) => c.label.startsWith('tod'))).toBe(true)
+    })
+  })
+
   describe('type completions', () => {
     it('should suggest types after colon', () => {
       const completions = getCompletions({