spl-lang 0.3.1 → 0.4.1

package/README.md

@@ -26,16 +26,22 @@ under `~/.spl` (override with `SPL_HOME`); `spl logout` removes those saved cred
 - **Generation:** `?` and `think` have no tools or MCP access.
 - **Agency:** `agent` explicitly enables model-directed runtime and configured MCP tools.
 - **Validation:** expression-valued `schema` uses strict synchronous JSON Schema draft-07;
-  `fmt='json'` accepts any JSON value, `fmt='object'` requires an object/array.
-  Prose and code fences are not silently extracted.
+  `fmt` supports `integer`, `float`, `array`, `object`, `text`, and `boolean`.
+  Non-text formats require strict JSON of the selected type; `float` accepts any finite
+  number, including whole numbers, and `object` requires a dict, not a list.
+  `fmt='json'` still accepts any JSON value. Prose and code fences are not silently extracted.
 - **Repairs:** `repairs=0..5` retries only malformed/invalid generation, not transport errors
   or external actions. Agents require `repairs=0`. Use `assert` for business rules.
 - **Guidance:** `enforce`/`forbid` and `len` influence prompts, not runtime guarantees.
 - **Capabilities:** nested `restrict fs/net/exec/mcp` clauses intersect. Shell command
   inspection is best effort; MCP servers are trusted services, not OS-sandboxed.
-- **Bindings:** `let` declares/redeclares function/script locals; `x = ...` and `x += ...`
-  update existing locals. Every block shares that scope. Enclosing names are readable but
-  cannot be rebound by a function; shared collections remain mutable.
+- **Bindings:** every block has a lexical child scope. `let` declares/redeclares locally
+  and shadows outer names. Reads and assignments search outward for the first declaration;
+  child locals, loop variables and caught failures do not leak to parents.
+- **Expressions:** blocks and conditionals yield their final expression, otherwise `None`.
+  `{}` remains an empty dict. Functions still require explicit `return`.
+- **Logging:** `log(...)` defaults to info. `log{level=debug}(...)` selects error/info/debug;
+  bare level names, strings and expressions are accepted and checked at runtime.
 
 Common generation modifiers are `len`, `fmt`, `reasoning`, `show`, `schema`, `repairs`,
 and `model`. Values are evaluated once, then validated before calling the model.
@@ -88,4 +94,6 @@ See [embedding](../docs/internals.html#embedding).
 Use `enforce` and `forbid` for scoped prompt guidance; `instruct` and `avoid` are not accepted.
 0.3 removes `think{level=...}`, tool-command syntax, and `let` before
 compound/member/index assignments. Use `reasoning`, ordinary raw functions, and explicit agents instead.
-Bare blocks no longer create scopes. See the [migration table](../README.md#breaking-changes-in-03).
+Blocks create lexical child scopes; replace inner `let` with assignment when an outer
+binding must be updated. See the [migration table](../README.md#breaking-changes-in-03).
+`fmt='object'` is now object-only; use `fmt='array'` for lists or `fmt='json'` for any JSON value.

package/dist/ast.d.ts

@@ -60,6 +60,22 @@ export type Expr = {
     obj: Expr;
     lo?: Expr;
     hi?: Expr;
+} | {
+    t: 'block';
+    body: Stmt[];
+    line: number;
+} | {
+    t: 'if';
+    branches: {
+        cond: Expr;
+        body: Stmt[];
+    }[];
+    orelse?: Stmt[];
+    line: number;
+} | {
+    t: 'log';
+    level: Expr;
+    args: Expr[];
 } | {
     t: 'ask' | 'think' | 'agent';
     mods: Record<string, Expr>;
@@ -67,7 +83,7 @@ export type Expr = {
 };
 export interface AskMods {
     len?: 'word' | 'sentence' | 'paragraph' | 'long';
-    fmt?: 'text' | 'object';
+    fmt?: 'integer' | 'float' | 'array' | 'object' | 'text' | 'boolean' | 'json';
 }
 export type ToolName = 'read_file' | 'write_file' | 'web_fetch' | 'web_search' | 'shell';
 export type RestrictKind = 'fs' | 'net' | 'exec' | 'mcp';

package/dist/interpreter.js

@@ -6,6 +6,12 @@ import { Restrictions, makeRestriction } from './restrict.js';
 import { MemoryStore } from './store.js';
 import { ToolHost, TOOL_SPECS } from './tools.js';
 import { compareValues, equals, hasKey, isDict, isFunction, isList, newDict, runtimeError, setKey, str, toJson, truthy, typeName, } from './values.js';
+class ExpressionSignal {
+    signal;
+    constructor(signal) {
+        this.signal = signal;
+    }
+}
 export async function run(program, opts) {
     return new Interpreter(program, opts).run();
 }
@@ -45,7 +51,7 @@ class Interpreter {
             const signal = await this.execBlock(this.program.body, this.globals);
             if (signal?.k === 'return')
                 return { status: 'success', value: signal.v, hasValue: signal.hasValue };
-            if (signal)
+            if (signal && signal.k !== 'value')
                 throw runtimeError(`'${signal.k}' outside of a loop`);
             return { status: 'success', value: null, hasValue: false };
         }
@@ -75,23 +81,33 @@ class Interpreter {
     }
     // ---- environments --------------------------------------------------
     lookup(name, env) {
-        for (let e = env; e; e = e.parent) {
-            if (e.vars.has(name))
-                return e.vars.get(name);
-        }
+        const scope = this.bindingScope(name, env);
+        if (scope)
+            return scope.vars.get(name);
         const b = this.builtins.get(name);
         if (b)
             return b;
         throw runtimeError(`name '${name}' is not defined`);
     }
+    bindingScope(name, env) {
+        for (let scope = env; scope; scope = scope.parent) {
+            if (scope.vars.has(name))
+                return scope;
+        }
+        return undefined;
+    }
+    childScope(parent) {
+        return { vars: new Map(), parent };
+    }
     // ---- statements ----------------------------------------------------
     async execBlock(stmts, env) {
+        let completion;
         for (const s of stmts) {
-            const signal = await this.execStmt(s, env);
-            if (signal)
-                return signal;
+            completion = await this.execStmt(s, env);
+            if (completion && completion.k !== 'value')
+                return completion;
         }
-        return undefined;
+        return completion;
     }
     async execStmt(s, env) {
         try {
@@ -99,6 +115,8 @@ class Interpreter {
             return await this.execStmtInner(s, env);
         }
         catch (e) {
+            if (e instanceof ExpressionSignal)
+                return e.signal;
             if (e instanceof Failure)
                 throw e.locate(s.line, this.program.lines[s.line - 1]?.trim() ?? '');
             if (e instanceof RangeError) {
@@ -116,10 +134,9 @@ class Interpreter {
                 await this.execAssign(s.target, s.op, s.value, env);
                 return;
             case 'block':
-                return this.execBlock(s.body, env);
+                return this.execBlock(s.body, this.childScope(env));
             case 'expr':
-                await this.eval(s.e, env);
-                return;
+                return { k: 'value', v: await this.eval(s.e, env) };
             case 'pass':
                 return;
             case 'break':
@@ -131,13 +148,13 @@ class Interpreter {
             case 'if': {
                 for (const b of s.branches) {
                     if (truthy(await this.eval(b.cond, env)))
-                        return this.execBlock(b.body, env);
+                        return this.execBlock(b.body, this.childScope(env));
                 }
-                return s.orelse ? this.execBlock(s.orelse, env) : undefined;
+                return s.orelse ? this.execBlock(s.orelse, this.childScope(env)) : undefined;
             }
             case 'while': {
                 while (truthy(await this.eval(s.cond, env))) {
-                    const sig = await this.execBlock(s.body, env);
+                    const sig = await this.execBlock(s.body, this.childScope(env));
                     if (sig?.k === 'break')
                         break;
                     if (sig?.k === 'return')
@@ -148,8 +165,9 @@ class Interpreter {
             case 'for': {
                 const items = iterate(await this.eval(s.iter, env));
                 for (let i = 0; i < items.length; i++) {
-                    this.bindLoopVars(s.vars, items[i], env);
-                    const sig = await this.execBlock(s.body, env);
+                    const scope = this.childScope(env);
+                    this.bindLoopVars(s.vars, items[i], scope);
+                    const sig = await this.execBlock(s.body, scope);
                     if (sig?.k === 'break')
                         break;
                     if (sig?.k === 'return')
@@ -167,7 +185,8 @@ class Interpreter {
                 const savedRestrictions = this.restrictions;
                 const savedDepth = this.depth;
                 try {
-                    return await this.execBlock(s.body, env);
+                    const completion = await this.execBlock(s.body, this.childScope(env));
+                    return completion?.k === 'value' ? undefined : completion;
                 }
                 catch (e) {
                     if (!(e instanceof Failure))
@@ -176,8 +195,10 @@ class Interpreter {
                     this.restrictions = savedRestrictions;
                     this.depth = savedDepth;
                     this.opts.logger.debug(`caught ${e.statusCode}: ${e.reason}`);
-                    env.vars.set(s.errName, newDict(Object.entries(e.payload())));
-                    return this.execBlock(s.handler, env);
+                    const scope = this.childScope(env);
+                    scope.vars.set(s.errName, newDict(Object.entries(e.payload())));
+                    const completion = await this.execBlock(s.handler, scope);
+                    return completion?.k === 'value' ? undefined : completion;
                 }
             }
             case 'assert': {
@@ -195,7 +216,8 @@ class Interpreter {
                 const saved = this.constraints;
                 this.constraints = [...saved, { kind: s.kind, text }];
                 try {
-                    return await this.execBlock(s.body, env);
+                    const completion = await this.execBlock(s.body, this.childScope(env));
+                    return completion?.k === 'value' ? undefined : completion;
                 }
                 finally {
                     this.constraints = saved;
@@ -209,7 +231,8 @@ class Interpreter {
                         this.restrictions = this.restrictions.with(restriction);
                         this.opts.logger.debug(`restrict ${clause.kind}: ${restriction.values.join(', ')}`);
                     }
-                    return await this.execBlock(s.body, env);
+                    const completion = await this.execBlock(s.body, this.childScope(env));
+                    return completion?.k === 'value' ? undefined : completion;
                 }
                 finally {
                     this.restrictions = saved;
@@ -233,9 +256,10 @@ class Interpreter {
             return op === '=' ? rhs : this.binary(op.slice(0, -1), current(), rhs);
         };
         if (target.t === 'name') {
-            if (!env.vars.has(target.name))
+            const scope = this.bindingScope(target.name, env);
+            if (!scope)
                 throw runtimeError(`cannot assign '${target.name}': declare a local with let first`);
-            env.vars.set(target.name, await compute(() => this.lookup(target.name, env)));
+            scope.vars.set(target.name, await compute(() => this.lookup(target.name, env)));
             return;
         }
         const obj = await this.eval(target.obj, env);
@@ -273,6 +297,22 @@ class Interpreter {
             case 'str': return this.text(e.parts, env);
             case 'bool': return e.v;
             case 'none': return null;
+            case 'block':
+            case 'if': {
+                const completion = await this.execStmt(e, env);
+                if (completion && completion.k !== 'value')
+                    throw new ExpressionSignal(completion);
+                return completion?.v ?? null;
+            }
+            case 'log': {
+                const level = await this.eval(e.level, env);
+                if (level !== 'error' && level !== 'info' && level !== 'debug') {
+                    throw runtimeError("log level must be 'error', 'info' or 'debug'");
+                }
+                const args = await this.evalArgs(e.args, env);
+                this.opts.logger[level](`log: ${args.map(str).join(' ')}`);
+                return null;
+            }
             case 'name': return this.lookup(e.name, env);
             case 'list': {
                 const out = [];
@@ -373,7 +413,7 @@ class Interpreter {
         this.depth++;
         try {
             const sig = await this.execBlock(fn.body, local);
-            if (sig && sig.k !== 'return')
+            if (sig && sig.k !== 'return' && sig.k !== 'value')
                 throw runtimeError(`'${sig.k}' outside of a loop`);
             return sig?.k === 'return' ? sig.v : null;
         }
@@ -527,8 +567,9 @@ class Interpreter {
         const fmt = options.fmt ?? ('schema' in options ? 'json' : 'text');
         if (len !== undefined && len !== 'word' && len !== 'sentence' && len !== 'paragraph' && len !== 'long')
             throw runtimeError('len must be word, sentence, paragraph, or long');
-        if (fmt !== 'text' && fmt !== 'json' && fmt !== 'object')
-            throw runtimeError('fmt must be text, json, or object');
+        if (fmt !== 'integer' && fmt !== 'float' && fmt !== 'array' && fmt !== 'object' && fmt !== 'text' && fmt !== 'boolean' && fmt !== 'json') {
+            throw runtimeError('fmt must be integer, float, array, object, text, boolean, or json');
+        }
         if (reasoning !== undefined && reasoning !== 'low' && reasoning !== 'medium' && reasoning !== 'high')
             throw runtimeError('reasoning must be low, medium, or high');
         if (typeof show !== 'boolean')
@@ -544,7 +585,7 @@ class Interpreter {
         const validate = 'schema' in options ? compileSchema(options.schema) : undefined;
         let prompt = buildPrompt({
             prompt: str(await this.eval(promptExpr, env)),
-            mods: { len, fmt: fmt === 'object' ? 'object' : undefined },
+            mods: { len, fmt },
             thinking: reasoning !== undefined,
             constraints: this.constraints,
             restrictions: this.restrictions,
@@ -564,7 +605,7 @@ class Interpreter {
                 tools: new ToolHost(this.restrictions, this.cwd, this.opts.backend.mode === 'replay'),
             });
             try {
-                const value = fmt === 'text' ? text : parseJsonResponse(text, fmt === 'object');
+                const value = fmt === 'text' ? text : parseJsonResponse(text, fmt);
                 validate?.(value);
                 return value;
             }

package/dist/lexer.js

@@ -16,6 +16,7 @@ export function tokenize(src, opts = {}) {
     let col = opts.col ?? 1;
     let depth = opts.inExpr ? 1 : 0;
     const brackets = [];
+    const braceDepths = [];
     const err = (msg, l = line, c = col) => {
         throw new SplSyntaxError(msg, l, c);
     };
@@ -83,7 +84,14 @@ export function tokenize(src, opts = {}) {
         if (!op)
             err(`unexpected character '${c}'`);
         advance(op.length);
-        if (op === '(' || op === '[') {
+        if (op === '{') {
+            braceDepths.push(depth);
+            depth = 0;
+        }
+        else if (op === '}') {
+            depth = braceDepths.pop() ?? depth;
+        }
+        else if (op === '(' || op === '[') {
             brackets.push(op);
             depth++;
         }

package/dist/llm.d.ts

@@ -31,6 +31,7 @@ export interface LlmBackend {
 /** Raised by a backend for any non-script-level LLM problem; becomes `llm_error`. */
 export declare class LlmError extends Error {
 }
+type JsonFormat = Exclude<NonNullable<AskMods['fmt']>, 'text'>;
 export declare function buildPrompt(opts: {
     prompt: string;
     mods?: AskMods;
@@ -38,4 +39,5 @@ export declare function buildPrompt(opts: {
     constraints: readonly Constraint[];
     restrictions: Restrictions;
 }): string;
-export declare function parseJsonResponse(text: string, objectOnly?: boolean): Value;
+export declare function parseJsonResponse(text: string, format?: JsonFormat): Value;
+export {};

package/dist/llm.js

@@ -10,6 +10,13 @@ const LEN_HINTS = {
     long: 'Give a long, detailed answer.',
 };
 const JSON_HINT = 'Respond with ONLY valid JSON. No prose, no markdown, no code fences.';
+const FORMAT_CONTRACTS = {
+    integer: { description: 'a JSON integer', accepts: (value) => typeof value === 'number' && Number.isInteger(value) },
+    float: { description: 'a finite JSON number', accepts: (value) => typeof value === 'number' && Number.isFinite(value) },
+    array: { description: 'a JSON array', accepts: isList },
+    object: { description: 'a JSON object', accepts: isDict },
+    boolean: { description: 'a JSON boolean (true or false)', accepts: (value) => typeof value === 'boolean' },
+};
 export function buildPrompt(opts) {
     const sections = [];
     if (opts.constraints.length) {
@@ -23,12 +30,13 @@ export function buildPrompt(opts) {
         sections.push('Think carefully about the problem before giving the final answer.');
     if (opts.mods?.len)
         sections.push(LEN_HINTS[opts.mods.len]);
-    if (opts.mods?.fmt === 'object')
-        sections.push(`${JSON_HINT} Return an object or array.`);
+    if (opts.mods?.fmt && opts.mods.fmt !== 'text' && opts.mods.fmt !== 'json') {
+        sections.push(`${JSON_HINT} Return ${FORMAT_CONTRACTS[opts.mods.fmt].description}.`);
+    }
     sections.push(opts.prompt);
     return sections.join('\n\n');
 }
-export function parseJsonResponse(text, objectOnly = false) {
+export function parseJsonResponse(text, format = 'json') {
     let value;
     try {
         value = fromJson(JSON.parse(text));
@@ -38,8 +46,8 @@ export function parseJsonResponse(text, objectOnly = false) {
             throw e;
         throw new Failure('invalid_format', `LLM response is not valid JSON: ${e.message}`);
     }
-    if (objectOnly && !isDict(value) && !isList(value)) {
-        throw new Failure('invalid_format', 'LLM response must be a JSON object or array');
+    if (format !== 'json' && !FORMAT_CONTRACTS[format].accepts(value)) {
+        throw new Failure('invalid_format', `LLM response must be ${FORMAT_CONTRACTS[format].description} (fmt='${format}')`);
     }
     return value;
 }

package/dist/parser.d.ts

@@ -1,3 +1,4 @@
 import type { Program } from './ast.js';
 export declare const MODIFIER_NAMES: readonly ['len', 'fmt', 'reasoning', 'show', 'schema', 'repairs', 'model'];
+export declare const LOG_MODIFIER_NAMES: readonly ['level'];
 export declare function parse(source: string): Program;

package/dist/parser.js

@@ -6,6 +6,7 @@ const KEYWORDS = new Set([
     'True', 'False', 'None',
 ]);
 export const MODIFIER_NAMES = ['len', 'fmt', 'reasoning', 'show', 'schema', 'repairs', 'model'];
+export const LOG_MODIFIER_NAMES = ['level'];
 const DIRECTIVE_SCHEMA = { model: 'string' };
 const ASSIGN_OPS = new Set(['=', '+=', '-=', '*=', '/=', '//=', '%=']);
 export function parse(source) {
@@ -160,7 +161,11 @@ class Parser {
     }
     parseBlock() {
         this.expectOp('{');
-        const body = [];
+        return this.finishBlock();
+    }
+    finishBlock(body = []) {
+        if (body.length)
+            this.endOfStatement();
         this.skipSeparators();
         while (!this.isOp('}')) {
             if (this.tok.type === 'eof')
@@ -180,7 +185,6 @@ class Parser {
         if (t.type === 'name') {
             switch (t.value) {
                 case 'let': return this.parseLet();
-                case 'if': return this.parseIf();
                 case 'for': {
                     this.next();
                     const vars = [this.expectIdent('a loop variable')];
@@ -257,8 +261,6 @@ class Parser {
                     break;
             }
         }
-        if (t.type === 'op' && t.value === '{')
-            return { t: 'block', line, body: this.parseBlock() };
         return this.parseSimpleStatement();
     }
     parseLet() {
@@ -353,7 +355,7 @@ class Parser {
             this.next();
             return { t: 'assign', line, target, op: t.value, value: this.parseExpr() };
         }
-        return { t: 'expr', line, e };
+        return e.t === 'block' || e.t === 'if' ? e : { t: 'expr', line, e };
     }
     toTarget(e, at) {
         if (e.t === 'name')
@@ -465,17 +467,7 @@ class Parser {
         let e = this.parsePrimary();
         for (;;) {
             if (this.isOp('(')) {
-                this.next();
-                const args = [];
-                while (!this.isOp(')')) {
-                    args.push(this.parseExpr());
-                    if (this.isOp(','))
-                        this.next();
-                    else if (!this.isOp(')'))
-                        this.fail("expected ',' or ')' in call");
-                }
-                this.next();
-                e = { t: 'call', callee: e, args };
+                e = { t: 'call', callee: e, args: this.parseArgs() };
             }
             else if (this.isOp('[')) {
                 this.next();
@@ -494,6 +486,19 @@ class Parser {
             }
         }
     }
+    parseArgs() {
+        this.expectOp('(');
+        const args = [];
+        while (!this.isOp(')')) {
+            args.push(this.parseExpr());
+            if (this.isOp(','))
+                this.next();
+            else if (!this.isOp(')'))
+                this.fail("expected ',' or ')' in call");
+        }
+        this.next();
+        return args;
+    }
     parseSubscript(obj) {
         const lo = this.isOp(':') ? undefined : this.parseExpr();
         if (lo && !this.isOp(':')) {
@@ -544,10 +549,19 @@ class Parser {
         }
         if (t.value === '{') {
             this.next();
-            this.skipNl();
+            this.skipSeparators();
+            if (this.isOp('}')) {
+                this.next();
+                return { t: 'dict', entries: [] };
+            }
+            const first = this.parseStatement();
+            const key = first.t === 'expr' ? first.e : first.t === 'if' || first.t === 'block' ? first : undefined;
+            if (!key || !this.isOp(':')) {
+                return { t: 'block', line: t.line, body: this.finishBlock([first]) };
+            }
             const entries = [];
+            let k = key;
             while (!this.isOp('}')) {
-                const k = this.parseExpr();
                 this.expectOp(':');
                 this.skipNl();
                 entries.push([k, this.parseExpr()]);
@@ -559,6 +573,8 @@ class Parser {
                 else if (!this.isOp('}')) {
                     this.fail("expected ',' or '}' in dict");
                 }
+                if (!this.isOp('}'))
+                    k = this.parseExpr();
             }
             this.next();
             return { t: 'dict', entries };
@@ -579,6 +595,16 @@ class Parser {
             case 'None':
                 this.next();
                 return { t: 'none' };
+            case 'if': return this.parseIf();
+            case 'log':
+                if (this.isOp('{', this.peekAt(1))) {
+                    this.next();
+                    const mods = this.parseMods('log');
+                    const level = mods.level ?? { t: 'str', parts: ['info'] };
+                    return { t: 'log', level, args: this.parseArgs() };
+                }
+                this.next();
+                return { t: 'name', name: t.value, line: t.line };
             case 'think':
             case 'agent': {
                 this.next();
@@ -601,19 +627,24 @@ class Parser {
         this.expectOp('{');
         this.skipNl();
         const out = {};
+        const allowed = cmd === 'log' ? LOG_MODIFIER_NAMES : MODIFIER_NAMES;
         while (!this.isOp('}')) {
             const nameTok = this.tok;
             if (nameTok.type !== 'name')
                 this.fail('expected a modifier name');
             const name = nameTok.value;
             this.next();
-            if (!MODIFIER_NAMES.some((allowed) => allowed === name)) {
-                this.fail(`unknown modifier '${name}' for '${cmd}' (allowed: ${MODIFIER_NAMES.join(', ')})`, nameTok);
+            if (!allowed.includes(name)) {
+                this.fail(`unknown modifier '${name}' for '${cmd}' (allowed: ${allowed.join(', ')})`, nameTok);
             }
             if (name in out)
                 this.fail(`duplicate modifier '${name}'`, nameTok);
             this.expectOp('=');
             out[name] = this.parseExpr();
+            const value = out[name];
+            if (cmd === 'log' && value.t === 'name' && ['error', 'info', 'debug'].includes(value.name)) {
+                out[name] = { t: 'str', parts: [value.name] };
+            }
             this.skipNl();
             if (this.isOp(',')) {
                 this.next();

package/docs/syntax.ebnf

@@ -24,10 +24,11 @@ guidance_stmt  = ( "enforce" | "forbid" ) , expr , block ;
 restrict_stmt  = "restrict" , restrict_clause , { "," , restrict_clause } , block ;
 restrict_clause = [ "fs" | "net" | "exec" | "mcp" ] , expr ;
 
-(* let declares/redeclares in the current function or script. All blocks share that scope.
-   Name assignment requires a declared local; it cannot rebind an enclosing function/script.
-   Functions read lexical enclosing scopes; collection mutations can share state.
-   Loop variables and caught failure names are local bindings.
+(* Every block creates a lexical child scope. let declares/redeclares locally and shadows parents.
+   Reads and assignments search outward for the first declaration; undeclared names are errors.
+   Each loop iteration has fresh locals; caught failure names belong to the handler scope.
+   Blocks/if yield their final expression, otherwise None. An unmatched if yields None.
+   {} remains an empty dict; { pass } is a block yielding None. Functions need explicit return.
    return exits the innermost function, or the script at top level.
    success exits the script, including when used in a function. *)
 
@@ -46,16 +47,20 @@ index          = "[" , expr , "]" ;
 slice          = "[" , [ expr ] , ":" , [ expr ] , "]" ;
 member         = "." , NAME ;
 primary        = NUMBER | string | "True" | "False" | "None" | NAME
-               | "(" , expr , ")" | list | dict
+               | "(" , expr , ")" | list | dict | block | if_stmt | log_expr
                | ( "think" | "agent" ) , [ modifiers ] , postfix ;
 list           = "[" , [ expr , { "," , expr } , [ "," ] ] , "]" ;
 dict           = "{" , [ expr , ":" , expr , { "," , expr , ":" , expr } , [ "," ] ] , "}" ;
 modifiers      = "{" , [ modifier , { "," , modifier } , [ "," ] ] , "}" ;
 modifier       = ( "len" | "fmt" | "reasoning" | "show" | "schema" | "repairs" | "model" ) , "=" , expr ;
+log_expr       = "log" , "{" , [ "level" , "=" , log_level , [ "," ] ] , "}" , call ;
+log_level      = "error" | "info" | "debug" | expr ;
 
 (* Unknown/duplicate modifier names are syntax errors. Values are expressions, validated at runtime:
    len: word/sentence/paragraph/long (guidance only)
-   fmt: text/json/object; schema implies json unless fmt is explicit
+   fmt: integer/float/array/object/text/boolean/json; schema implies json unless fmt is explicit
+   Non-text formats require strict JSON of the selected type; float accepts finite numbers,
+   object excludes arrays, and json accepts any JSON value.
    reasoning: low/medium/high; think and agent default to medium
    show: True/False; schema: synchronous strict JSON Schema draft-07 object or boolean
    repairs: integer 0..5 (additional generation attempts, default 0); agents require 0
@@ -63,6 +68,9 @@ modifier       = ( "len" | "fmt" | "reasoning" | "show" | "schema" | "repairs" |
    Generation (? and think) has no tools. agent explicitly enables restricted runtime/MCP tools.
    Raw tools are ordinary positional functions: read_file(path), write_file(path, content),
    web_fetch(url), web_search(query), shell(command). They never invoke a model.
+   log{level=...}(args) selects error/info/debug severity; plain log(args) defaults to info.
+   Level values are bare names, strings or expressions, validated before evaluating arguments.
+   Debug messages are emitted only at debug log level; silent suppresses all logs.
    enforce/forbid are scoped prompt guidance.
    schema/assert validate data; restrict checks actions. *)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spl-lang",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Semantic Prompt Language: a Python-like language with LLM calls built into the syntax",
   "type": "module",
   "main": "./dist/index.js",