Compile sync where provable: maybe-await call sites, sync demotion, let flattening

The eval-capable backend compiled essentially every lambda async and
awaited every head call; only leaf functions over primitives were
demoted to sync. JSC pays heavily for async frames and promise
allocation, making the kernel suite ~2x slower on Bun than Node.

Three changes, all dynamic - eval redefinition keeps working with no
opt-in restrictions:

- Maybe-await: head calls in async contexts compile to
  (w$ = $.t(f(...))) instanceof Promise ? await w$ : w$, with one
  let-declared slot per function. Callers suspend only when the callee
  actually returned a Promise, so redefining any function to an async
  replacement just makes call sites take the await branch.
- Structural sync demotion: any compiled arrow whose body contains no
  await is emitted as a plain function. Subsumes the leaf rule and adds
  tail-call-only functions (their calls are $.b bounces). 66% of
  kernel lambdas are now sync.
- Let flattening: inside a function, (let X Y Z) compiles to
  (X$tN = Y, Z) with per-function alpha-renaming and block-scoped
  declarations instead of an awaited async iife. Awaited iifes in the
  rendered kernel: 2330 -> 41 (remaining traps). Fixed a latent alias
  bug en route: buildApp's local-callee path used raw SafeId instead of
  variable(), breaking alpha-renamed bindings.
- funSyncGeneric over-application chains through then() when settle
  yields a Promise (sync wrapper trampolining into an async function).

Kernel certification suite (134/134 everywhere, serial A/B, node
v25.4.0 / bun 1.3.14 / deno 2.8.3): node 15.3s -> 10.1s (~1.58x), bun
33.5s -> 19.5s (~1.77x), deno 13.8s -> 9.8s (~1.49x). AOT artifacts
also faster (fib 210 -> 83 ms under load). All suites green: backend
369, frontend 10, extensions, ratatoskr e2e, smoke on all three
runtimes, REPL interactive smoke.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Reuben Brooks

bin/ratatoskr-build.js

@@ -32,7 +32,7 @@ import backend from '../lib/backend.js';
 import overrides from '../lib/overrides.js';
 import { parseFile } from '../scripts/parser.js';
 import {
-  Arrow, Block, Call, Const, Id, Program, Return, Statement, generate
+  Arrow, Block, Call, Const, Id, Let, Program, Return, Statement, generate
 } from '../lib/ast.js';
 
 const USAGE = 'usage: node bin/ratatoskr-build.js <shaken-dir> <out.js> [--linked]';
@@ -146,6 +146,7 @@ const program = generate(Program([
   Const(Id('run'), Arrow(
     [Id('$')],
     Block(
+      Let(Id('w$')), // maybe-await slot for top-level forms (see lib/backend.js)
       ...Object.entries(body.subs).map(([key, value]) => Const(Id(key), value)),
       ...body.ast.body,
       Return(Id('$'))),

lib/ast.js

@@ -53,6 +53,7 @@ const Iife = (params, args, body, async = false) => Call(Arrow(params, body, asy
 const Let = (id, init) => Local('let', id, init);
 const Literal = value => ({ type: 'Literal', value });
 const Local = (kind, id, init) => ({ type: 'VariableDeclaration', kind, declarations: [{ type: 'VariableDeclarator', id, init }] });
+const Lets = ids => ({ type: 'VariableDeclaration', kind: 'let', declarations: ids.map(id => ({ type: 'VariableDeclarator', id })) });
 const Member = (object, property) =>
   property.type === 'Literal' && validName(property.value)
     ? { type: 'MemberExpression', object, property: Id(property.value) }
@@ -92,7 +93,7 @@ const ExportDefault = declaration => ({ type: 'ExportDefaultDeclaration', declar
 
 export {
   Arrow, Assign, Async, Await, Binary, Block, Call, Catch, Class, Conditional, Const, Debugger, DoWhile,
-  Empty, ExportDefault, For, ForIn, ForOf, Generator, Id, If, Iife, ImportDefault, Let, Literal, Local, Member,
+  Empty, ExportDefault, For, ForIn, ForOf, Generator, Id, If, Iife, ImportDefault, Let, Lets, Literal, Local, Member,
   New, NewObj, NewTarget, Procedure, Program, Property, Return, SafeId, Sequence, Slot, Spread, Statement, Static,
   Super, TaggedTemplate, Template, TemplateElement, TemplateLiteral, This, Try, Unary, Var, Vector, While,
   Yield, YieldMany,

lib/backend.js

@@ -1,5 +1,5 @@
 import {
-  Arrow, Binary, Block, Call, Catch, Conditional, Id, Iife, Literal,
+  Arrow, Assign, Await, Binary, Block, Call, Catch, Conditional, Id, Iife, Lets, Literal,
   Member, Return, SafeId, Sequence, Template, Try, Unary, Vector,
   generate, isStatement
 } from './ast.js';
@@ -101,6 +101,50 @@ const hasExternalCalls = (f, body) => {
   }
   return externals.size > 0;
 };
+// Scans a built syntax tree for awaits (bit 1) and uses of the w$ maybe-await
+// slot (bit 2) belonging to the current function level: awaits nested in inner
+// functions suspend the inner function, not this one, and every function that
+// uses w$ declares its own, so the scan stops at function boundaries.
+// Memoised: build is bottom-up and never adds awaits into an
+// already-constructed node, so results are stable.
+const scanCache = new WeakMap();
+const scan = node => {
+  if (!node || typeof node !== 'object') {
+    return 0;
+  }
+  if (scanCache.has(node)) {
+    return scanCache.get(node);
+  }
+  const result =
+    isArray(node) ? node.reduce((r, x) => r | scan(x), 0) :
+    node.type === 'ArrowFunctionExpression'
+      || node.type === 'FunctionExpression' ? 0 :
+    (node.type === 'AwaitExpression' ? 1 : 0)
+      | (node.type === 'Identifier' && node.name === 'w$' ? 2 : 0)
+      | Object.values(node).reduce((r, x) => r | scan(x), 0);
+  scanCache.set(node, result);
+  return result;
+};
+const containsAwait = node => (scan(node) & 1) !== 0;
+const usesSlot = node => (scan(node) & 2) !== 0;
+// Settled calls in async position only suspend when the callee actually
+// returned a Promise: (w$ = $.t(f(...))) instanceof Promise ? await w$ : w$.
+// w$ is declared once per enclosing function (see functionBody), so each
+// invocation has its own slot; the assign-test-await sequence is synchronous,
+// making reuse of one slot for every call site in the function safe.
+const MaybeAwait = ast =>
+  Conditional(
+    Binary('instanceof', Assign(Id('w$'), ast), Id('Promise')),
+    Await(Id('w$')),
+    Id('w$'));
+// Function bodies declare the maybe-await slot (when used at this level) and
+// the flattened let bindings collected while building the body (see buildLet).
+// Declarations are per-function, so every invocation gets fresh bindings for
+// closures to capture.
+const functionBody = (temps, body) => {
+  const names = [...(usesSlot(body) ? ['w$'] : []), ...temps];
+  return names.length === 0 ? body : Block(Lets(names.map(x => Id(x))), Return(body));
+};
 const fabricate = (x, subs) =>
   !(x instanceof Fabrication) ? new Fabrication(x, subs) :
   subs                        ? new Fabrication(x.ast, Object.assign({}, x.subs, subs)) :
@@ -113,7 +157,10 @@ const inject = (name, f) => {
   const placeholder = SafeId(name, '$c');
   return fabricate(f(placeholder), { [placeholder.name]: Call(Member$('c'), [Literal(name)]) });
 };
-const variable = (context, symbol) => ann(context.get(symbol).dataType, SafeId(nameOf(symbol)));
+const variable = (context, symbol) => {
+  const { dataType, id } = context.get(symbol);
+  return ann(dataType, id ? Id(id) : SafeId(nameOf(symbol)));
+};
 const idle = symbol => {
   const name = nameOf(symbol);
   const placeholder = ann('Symbol', SafeId(name, '$s'));
@@ -164,31 +211,67 @@ const buildDo = (context, [_do, ...exprs]) =>
     Sequence,
     ...most(exprs).map(x => build(context.now(), x)),
     uncast(build(context, last(exprs))));
-const buildLet = (context, [_let, symbol, binding, body]) =>
-  assemble(
-    (y, z) => Call(Arrow([SafeId(nameOf(symbol))], z, context.async), [y], context.async),
+// Inside a function, (let X Y Z) flattens to the sequence (X$tN = Y, Z) with
+// X$tN alpha-renamed (unique per enclosing function) and declared in the
+// function body (see functionBody): no iife, no promise, no await. Each let
+// expression evaluates at most once per invocation of its enclosing function
+// (KLambda has no loops), so single assignment per fresh binding holds and
+// closures capture the right value. The $t suffix cannot collide with
+// escaped names ($xx hex pairs), cells ($c), idles ($s) or params ($N$).
+// At top level there is no enclosing function to host the declaration, so
+// the historical iife form is kept.
+const buildLet = (context, [_let, symbol, binding, body]) => {
+  if (!context.fn) {
+    return assemble(
+      (y, z) => {
+        const async = context.async && containsAwait(z);
+        return Call(Arrow([SafeId(nameOf(asSymbol(symbol)))], functionBody([], z), async), [y], async);
+      },
+      uncast(build(context.now(), binding)),
+      uncast(build(context.add([asSymbol(symbol), {}]), body)));
+  }
+  const name = `${SafeId(nameOf(asSymbol(symbol))).name}$t${context.fn.n++}`;
+  context.fn.temps.push(name);
+  return assemble(
+    (y, z) => Sequence(Assign(Id(name), y), z),
     uncast(build(context.now(), binding)),
-    uncast(build(context.add([asSymbol(symbol), {}]), body)));
+    uncast(build(context.add([asSymbol(symbol), { id: name }]), body)));
+};
+const trapBlock = statement =>
+  Block(...(usesSlot(statement) ? [Lets([Id('w$')])] : []), statement);
 const buildTrap = (context, [_trap, body, handler]) =>
   isForm(handler, 3, 'lambda')
     ? assemble(
-        (x, y) =>
-          Iife([], [], Block(Try(
+        (x, y) => {
+          const async = context.async && (containsAwait(x) || containsAwait(y));
+          return Iife([], [], trapBlock(Try(
             Block(Return(x)),
-            Catch(SafeId(nameOf(handler[1])), Block(Return(y))))), context.async),
+            Catch(SafeId(nameOf(handler[1])), Block(Return(y))))), async);
+        },
         uncast(build(context.now(), body)),
         uncast(build(context.add([asSymbol(handler[1]), { dataType: 'Error' }]), handler[2])))
     : assemble(
         (x, y) =>
-          Iife([], [], Block(Try(
+          Iife([], [], trapBlock(Try(
             Block(Return(x)),
             Catch(Id('e$'), Block(Return(Call(y, [Id('e$')])))))), context.async),
         uncast(build(context.now(), body)),
         uncast(build(context, handler)));
-const buildFunction = (context, params, body) =>
-  assemble(
-    b => Call$('l', [Arrow(params.map(x => isSymbol(x) ? SafeId(nameOf(x)) : x), b, context.async)]),
-    uncast(build(context.later().add(...params.filter(isSymbol).map(x => [x, {}])), body)));
+const buildFunction = (context, params, body) => {
+  const fn = { temps: [], n: 0 };
+  return assemble(
+    b => {
+      // demote to a plain function when the compiled body never suspends:
+      // callers always settle or maybe-await results, so a sync callee just
+      // means the await gets skipped
+      const async = context.async && containsAwait(b);
+      return Call$('l', [Arrow(
+        params.map(x => isSymbol(x) ? SafeId(nameOf(x)) : x),
+        functionBody(fn.temps, b),
+        async)]);
+    },
+    uncast(build(context.later().with({ fn }).add(...params.filter(isSymbol).map(x => [x, {}])), body)));
+};
 const buildNestedLambda = (context, params, body) =>
   isForm(body, 3, 'lambda')
     ? buildNestedLambda(context, [...params.map((p, i) => p === body[1] ? Id(`$${i}$`) : p), body[1]], body[2])
@@ -232,10 +315,11 @@ const buildInline = (context, [fExpr, ...argExprs]) =>
     ...argExprs.map(x => build(context.now(), x)));
 const buildApp = (context, [fExpr, ...argExprs]) =>
   assemble(
-    (f, ...args) => context.head
-      ? Call$('t', [Call(f, args)], context.async)
-      : Call$('b', [f, ...args]),
-    context.has(fExpr) ? fabricate(SafeId(nameOf(fExpr))) :
+    (f, ...args) =>
+      !context.head  ? Call$('b', [f, ...args]) :
+      context.async  ? MaybeAwait(Call$('t', [Call(f, args)])) :
+      Call$('t', [Call(f, args)]),
+    context.has(fExpr) ? fabricate(variable(context, fExpr)) :
     isArray(fExpr)     ? uncast(build(context.now(), fExpr)) :
     isSymbol(fExpr)    ? inject(nameOf(fExpr), x => Member(x, Id('f'))) :
     raise('not a valid application form'),
@@ -263,7 +347,9 @@ const build = (context, expr) =>
   isArray(expr)                 ? buildApp   (context, expr) :
   raise('not a valid form');
 const hoist = (fabr, async = false) =>
-  fabr.keys.length === 0 ? fabr.ast : Iife(fabr.keys.map(x => Id(x)), fabr.values, fabr.ast, async);
+  fabr.keys.length === 0 && !async
+    ? fabr.ast
+    : Iife(fabr.keys.map(x => Id(x)), fabr.values, functionBody([], fabr.ast), async);
 
 export default (options = {}) => {
   const $ = runtime(options);

lib/runtime.js

@@ -105,9 +105,16 @@ export default (options = {}) => {
   // goes through the fixed-parameter wrappers below, which avoid
   // materializing a rest array on every call (a dominant cost on JSC and a
   // measurable one on V8). `args` must be a real array here.
+  // settling a sync function's result can still yield a Promise (a sync
+  // wrapper may trampoline into an async function), so over-application
+  // chains through then() in that case instead of assuming a settled value
+  const applyTo = (g, args) =>
+    g instanceof Promise
+      ? g.then(h => asFunction(h)(...args))
+      : asFunction(g)(...args);
   const funSyncGeneric = (f, arity, args) =>
     args.length === arity ? f(...args) :
-    args.length > arity ? bounce(() => asFunction(settle(f(...args.slice(0, arity))))(...args.slice(arity))) :
+    args.length > arity ? bounce(() => applyTo(settle(f(...args.slice(0, arity))), args.slice(arity))) :
     args.length === 0 ? funSync(f, arity) :
     Object.assign(funSync((...more) => f(...args, ...more), arity - args.length), { arity: f.arity - args.length });
   const funAsyncGeneric = (f, arity, args) =>

scripts/render.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { parseKernel } from './parser.js';
 import backend from '../lib/backend.js';
 import {
-  Arrow, Block, Call, Const, ExportDefault, Id, ImportDefault, Program, Return, Statement,
+  Arrow, Block, Call, Const, ExportDefault, Id, ImportDefault, Let, Program, Return, Statement,
   generate
 } from '../lib/ast.js';
 import { formatDuration, formatGrid, measure } from './utils.js';
@@ -29,6 +29,7 @@ const measureRender = measure(() => {
       ExportDefault(Arrow(
         [Id('$')],
         Block(
+          Let(Id('w$')), // maybe-await slot for top-level forms (see lib/backend.js)
           ...Object.entries(body.subs).map(([key, value]) => Const(Id(key), value)),
           ...body.ast.body,
           Return(Id('$'))),