@omgbase/oqx 0.20.0 → 0.21.0

package/src/ast.ts

@@ -35,6 +35,10 @@ export type UnaryOp = "!" | "-";
 /** The operator of a `logical` expression. */
 export type LogicalOp = "&&" | "||";
 
+/** One part of a template literal (since 0.21): a decoded text run, or an
+ * interpolated expression. The strings are not nodes (no `kind`, no span). */
+export type TemplatePart = string | Expr;
+
 /** Scalar value/predicate expression, evaluated against a row scope + bindings. */
 export type Expr =
   | { kind: "lit"; span: Span; value: string | number | boolean | null }
@@ -58,6 +62,12 @@ export type Expr =
   // receiver (`(a, b) { … }`, `follow (a, b) { depth 2 }`). One expression in
   // parentheses is grouping and leaves no node.
   | { kind: "tuple"; span: Span; items: Expr[] }
+  // A template literal `` `text ${expr} text` `` (since 0.21): `parts` alternates
+  // strictly — text, interpolation, text, … — so it always has an odd length and
+  // begins and ends with a (possibly empty) text part; the text is decoded (the
+  // GRAMMAR §1 escapes resolved). Evaluates to the concatenation of the text and
+  // the interpolated values' string forms (SEMANTICS §7b).
+  | { kind: "template"; span: Span; parts: TemplatePart[] }
   // A value-position directive (since 0.17): `recv first { … }.pay`, and what a
   // bracket lookup `x[…]` desugars to. `isExpr` is false for it — an op is an
   // expression only by position; discriminate on `kind === "op"`.
@@ -193,7 +203,7 @@ export type AstKind = AstNode["kind"];
 
 /** The expression kinds (`Expr["kind"]`), for `isExpr`. */
 const EXPR_KINDS: ReadonlySet<string> = new Set([
-  "lit", "ident", "outer", "binding", "member", "call", "unary", "required", "binary", "logical", "in", "range", "tuple",
+  "lit", "ident", "outer", "binding", "member", "call", "unary", "required", "binary", "logical", "in", "range", "tuple", "template",
 ]);
 
 /** Whether a node is a scalar `Expr` (an `op` in expression position is not: it

package/src/build.ts

@@ -5,7 +5,7 @@
 
 import type {
   BinaryOp, Consumer, CountCmp, Expr, Follow, FollowDestination, LogicalOp, OpNode, OrderSpec, Query, SelectItem, Span,
-  Subquery, UnaryOp, Where,
+  Subquery, TemplatePart, UnaryOp, Where,
 } from "./ast.ts";
 
 /** A fresh empty span (never shared: spans are mutable tuples). */
@@ -28,6 +28,9 @@ export const inOp = (left: Expr, right: Expr): Expr => ({ kind: "in", span: span
 export const range = (lo: Expr | null, hi: Expr | null, exclusiveEnd = false): Expr => ({ kind: "range", span: span(), lo, hi, exclusiveEnd });
 /** `(e1, e2, …)` — a tuple of two or more expressions (SEMANTICS §3b). */
 export const tuple = (items: Expr[]): Expr => ({ kind: "tuple", span: span(), items });
+/** `` `text ${expr} …` `` — a template literal (SEMANTICS §7b); `parts` alternates
+ * text, expression, text, … (odd length, text first and last). */
+export const template = (parts: TemplatePart[]): Expr => ({ kind: "template", span: span(), parts });
 
 export const scalar = (expr: Expr): Where => ({ kind: "scalar", span: span(), expr });
 export const and = (parts: Where[]): Where => ({ kind: "and", span: span(), parts });

package/src/engine.ts

@@ -26,7 +26,7 @@ import type { DataContext } from "./context.ts";
 import { DefaultContext } from "./context.ts";
 import { OqxError } from "./errors.ts";
 import {
-  relate, arith, membership, truthy, compareForSort, compare, canonicalKey, makeRange, isEntry, isRange,
+  relate, arith, membership, truthy, compareForSort, compare, canonicalKey, makeRange, isEntry, isRange, stringForm,
 } from "./semantics.ts";
 import type { BlockPlan, Correlation, Rule, RowIndex } from "./optimize/index.ts";
 import { printTemplate } from "./print.ts";
@@ -904,6 +904,26 @@ export class InMemoryEngine implements Engine {
         }
         return out;
       }
+      // A template literal (SEMANTICS §7b): the text parts verbatim and each
+      // interpolated value's string form (§7), concatenated. Every interpolation
+      // is evaluated, in order; a list, a record or a range is an eval error (it
+      // has no string form the language specifies); an absent value makes the
+      // whole literal absent, as `+` does.
+      case "template": {
+        let out = "";
+        let absent = false;
+        for (const part of e.parts) {
+          if (typeof part === "string") { out += part; continue; }
+          const v = this.evalExpr(part, scope);
+          if (v == null) { absent = true; continue; }
+          if (typeof v === "object") {
+            const what = isRange(v) ? "a range" : Array.isArray(v) || Symbol.iterator in v ? "a list" : "a record";
+            throw new OqxError(`cannot interpolate \`\${${describe(part)}}\` in a template literal: it is ${what} — only a string, a number, a boolean or an absent value has a string form`, "eval");
+          }
+          out += stringForm(v)!;
+        }
+        return absent ? undefined : out;
+      }
     }
   }
 
@@ -1093,6 +1113,7 @@ function exprHasRecur(e: Expr): boolean {
     case "binary": case "logical": case "in": return exprHasRecur(e.left) || exprHasRecur(e.right);
     case "range": return (e.lo != null && exprHasRecur(e.lo)) || (e.hi != null && exprHasRecur(e.hi));
     case "tuple": return e.items.some(exprHasRecur);
+    case "template": return e.parts.some((p) => typeof p !== "string" && exprHasRecur(p));
     default: return false;
   }
 }

package/src/lexer.ts

@@ -10,7 +10,14 @@
 // alter the grammar — the prepared-statement / injection-safe property the
 // host-bindings design note calls for. (A consequence: `${x}` inside a string
 // literal does not interpolate — that fragment would be an unterminated string —
-// which is exactly the desired "interpolation is a value, never source text".)
+// which is exactly the desired "interpolation is a value, never source text".
+// The same holds for a backtick template literal (0.21): a fragment that ends
+// inside one is an unterminated literal, so a bound value never stands in one.)
+//
+// Template literals `` `text ${expr}` `` are lexed with a mode stack: the text
+// between the backticks is one `tmpl_text` token per run (decoded), a `${`
+// opens an interpolation whose tokens are ordinary source until the `}` that
+// balances it, and an interpolation may hold another template literal.
 //
 // Positions (`Token.pos` / `Token.end`, the `span` of every AST node, and the
 // offsets quoted in error messages) count Unicode CODE POINTS over the raw
@@ -39,13 +46,21 @@ export type TokType =
   | "range" // `..` (inclusive) or `...` (exclusive end) — a Ruby-style range operator (value carries which)
   | "op" // == != <= >= < > && || ! + - * / %  (value carries the operator)
   | "binding" // a ${…} interpolation; `index` names the value slot
+  // A template literal (since 0.21): the opening and closing backticks, a run of
+  // its decoded text, and the `${` / `}` around an interpolation — whose `}` is a
+  // token of its own, so a block's `}` inside the interpolation stays `rbrace`.
+  | "tmpl_start"
+  | "tmpl_text"
+  | "tmpl_interp_start"
+  | "tmpl_interp_end"
+  | "tmpl_end"
   | "eof";
 
 export interface Token {
   type: TokType;
   /** The source text of the token, except: a `string` token carries its decoded
-   * value (quotes stripped, escapes resolved); a `binding` carries the display
-   * marker `${N}`; `eof` carries `""`. */
+   * value (quotes stripped, escapes resolved), and so does a `tmpl_text` run; a
+   * `binding` carries the display marker `${N}`; `eof` carries `""`. */
   value: string;
   /** Code-point offset of the token's first character. */
   pos: number;
@@ -78,7 +93,16 @@ export function lexTemplate(fragments: readonly string[], values: number): Token
   const tokens: Token[] = [];
   let base = 0; // running offset across fragments + rendered `${…}` markers
   for (let f = 0; f < fragments.length; f++) {
-    lexFragment(fragments[f]!, base, tokens);
+    try {
+      lexFragment(fragments[f]!, base, tokens);
+    } catch (err) {
+      // A fragment ends inside a backtick literal: the bound value would have
+      // to stand inside it, and a bound value is never source text (GRAMMAR §1).
+      if (err instanceof OqxError && f < fragments.length - 1 && err.message.startsWith("unterminated template literal")) {
+        throw new OqxError(`${err.message} — a template literal must be complete within one fragment: a \${…} binding cannot stand inside a backtick literal (interpolate a name, or bind the whole string)`, "lex");
+      }
+      throw err;
+    }
     base += codePointLength(fragments[f]!);
     if (f < fragments.length - 1) {
       // account for the value's rendered width in the display source (see rawSource)
@@ -103,6 +127,14 @@ export function lexString(src: string): Token[] {
   return tokens;
 }
 
+// The lexer's mode inside a template literal (GRAMMAR §1, since 0.21): the text of
+// the literal, or a `${…}` interpolation, which is ordinary source again — with a
+// brace depth, so the `}` that closes the interpolation is told from a block's.
+// Nesting is a stack: an interpolation may hold another template literal.
+type Mode =
+  | { kind: "template"; start: number }
+  | { kind: "interp"; start: number; depth: number };
+
 function lexFragment(src: string, base: number, out: Token[]): void {
   // One entry per code point, so every index below is a code-point offset.
   const cps = Array.from(src);
@@ -113,16 +145,47 @@ function lexFragment(src: string, base: number, out: Token[]): void {
   const push = (type: TokType, value: string, start: number, end: number): void => {
     out.push({ type, value, pos: base + start, end: base + end });
   };
+  const modes: Mode[] = [];
 
   while (i < n) {
+    const mode = modes[modes.length - 1];
+
+    // Template text: everything up to the closing backtick or the `${` of an
+    // interpolation, decoded with the string escapes (`\<c>` is `<c>`, so `` \` ``
+    // and `\$` keep a backtick or a dollar literal). Newlines are kept verbatim.
+    if (mode?.kind === "template") {
+      const start = i;
+      let sval = "";
+      while (i < n) {
+        const c = cps[i]!;
+        if (c === "`" || (c === "$" && at(i + 1) === "{")) break;
+        if (c === "\\") { i++; sval += unescape(cps[i]); i++; continue; }
+        sval += c;
+        i++;
+      }
+      if (i > start) push("tmpl_text", sval, start, Math.min(i, n));
+      if (i >= n) break; // unterminated — reported below
+      if (cps[i] === "`") { push("tmpl_end", "`", i, i + 1); i++; modes.pop(); continue; }
+      push("tmpl_interp_start", "${", i, i + 2);
+      modes.push({ kind: "interp", start: i, depth: 0 });
+      i += 2;
+      continue;
+    }
+
     const c = cps[i]!;
 
     if (c === " " || c === "\t" || c === "\n" || c === "\r") { i++; continue; }
 
+    if (c === "`") { push("tmpl_start", c, i, i + 1); modes.push({ kind: "template", start: i }); i++; continue; }
     if (c === "(") { push("lparen", c, i, i + 1); i++; continue; }
     if (c === ")") { push("rparen", c, i, i + 1); i++; continue; }
-    if (c === "{") { push("lbrace", c, i, i + 1); i++; continue; }
-    if (c === "}") { push("rbrace", c, i, i + 1); i++; continue; }
+    if (c === "{") { if (mode) mode.depth++; push("lbrace", c, i, i + 1); i++; continue; }
+    if (c === "}") {
+      // Inside an interpolation a `}` at depth 0 closes it; deeper, it closes a block.
+      if (mode && mode.depth === 0) { push("tmpl_interp_end", c, i, i + 1); i++; modes.pop(); continue; }
+      if (mode) mode.depth--;
+      push("rbrace", c, i, i + 1); i++; continue;
+    }
     if (c === "[") { push("lbracket", c, i, i + 1); i++; continue; }
     if (c === "]") { push("rbracket", c, i, i + 1); i++; continue; }
     if (c === ",") { push("comma", c, i, i + 1); i++; continue; }
@@ -200,6 +263,13 @@ function lexFragment(src: string, base: number, out: Token[]): void {
 
     throw new OqxError(`unexpected character ${JSON.stringify(c)} at ${base + i}`, "lex");
   }
+
+  // The end of the source inside a template literal.
+  const open = modes[modes.length - 1];
+  if (open?.kind === "template") throw new OqxError(`unterminated template literal at ${base + open.start}`, "lex");
+  if (open?.kind === "interp") {
+    throw new OqxError(`unterminated \${…} interpolation in a template literal at ${base + open.start} — expected '}'`, "lex");
+  }
 }
 
 // Scan a number whose first digit is at `i`; return the index just past it.

package/src/optimize/analysis.ts

@@ -35,6 +35,7 @@ export function exprReadsScopeIn(e: Expr, at: number, upTo: number): boolean {
     case "binary": case "logical": case "in": return exprReadsScopeIn(e.left, at, upTo) || exprReadsScopeIn(e.right, at, upTo);
     case "range": return (e.lo !== null && exprReadsScopeIn(e.lo, at, upTo)) || (e.hi !== null && exprReadsScopeIn(e.hi, at, upTo));
     case "tuple": return e.items.some((x) => exprReadsScopeIn(x, at, upTo));
+    case "template": return e.parts.some((p) => typeof p !== "string" && exprReadsScopeIn(p, at, upTo));
   }
 }
 
@@ -101,6 +102,9 @@ export function exprRaiseFree(e: Expr, ctx: RuleContext): boolean {
     case "binary": case "logical": case "in": return exprRaiseFree(e.left, ctx) && exprRaiseFree(e.right, ctx);
     case "range": return (e.lo === null || exprRaiseFree(e.lo, ctx)) && (e.hi === null || exprRaiseFree(e.hi, ctx));
     case "tuple": return e.items.every((x) => exprRaiseFree(x, ctx));
+    // A template literal raises on a list or record interpolation (§7b), which
+    // only the data decides: with an interpolation it is never raise-free.
+    case "template": return e.parts.every((p) => typeof p === "string");
   }
 }
 

package/src/parser.ts

@@ -64,6 +64,11 @@
 // Tuples (0.20): `(e1, e2, …)` with two or more elements is a `tuple` node — a
 // value and a receiver; one expression in parentheses stays grouping.
 //
+// Template literals (0.21): `` `text ${expr} text` `` is a `template` node — a
+// primary value whose interpolations are full expressions read at the current
+// depth (`parseTemplateLiteral`); the lexer balances the braces, so an
+// interpolation may hold a `{ … }` block or another template literal.
+//
 // Principle of least surprise, applied to the grammar: a rule a careful user
 // would not predict is a bug. Hence `!` binds tighter than comparison in every
 // position (`!a == b` is `(!a) == b`, as in C); parentheses in `where` group a
@@ -78,7 +83,7 @@ import { lexTemplate, lexString } from "./lexer.ts";
 import { OqxError } from "./errors.ts";
 import type {
   Query, Where, Expr, OpNode, Subquery, SelectItem, OrderSpec, Follow, FollowDestination, Consumer, RelOp,
-  BinaryOp, Span,
+  BinaryOp, Span, TemplatePart,
 } from "./ast.ts";
 import { resolveSelect, resolveWhere } from "./resolve.ts";
 import { printTemplate } from "./print.ts";
@@ -194,7 +199,10 @@ class Parser {
     return t.type === "op" && t.value === value;
   }
   private fail(msg: string): never {
-    throw new OqxError(`${msg} (at offset ${this.peek().pos})`, "parse");
+    this.failAt(this.peek().pos, msg);
+  }
+  private failAt(pos: number, msg: string): never {
+    throw new OqxError(`${msg} (at offset ${pos})`, "parse");
   }
   /** Code-point offset of the next token (the start of a node about to be parsed). */
   private start(): number { return this.peek().pos; }
@@ -1042,7 +1050,7 @@ class Parser {
   // `recv first { where p }`; a trailing `!` makes the index required and the
   // predicate a `single` (required too, so that zero matches is an error).
   private parseBracket(recv: Expr): Expr {
-    if (recv.kind === "lit") this.fail(`\`${describe(recv)}\` is a literal, not a collection`);
+    if (recv.kind === "lit" || recv.kind === "template") this.fail(`\`${describe(recv)}\` is a literal, not a collection`);
     const start = recv.span[0];
     const lbracket = this.next().pos; // '['
     let index: Expr | null = null;
@@ -1170,7 +1178,7 @@ class Parser {
     if (!t) return false;
     if (t.type === "ident") return !CLAUSE_WORDS.has(t.value);
     if (t.type === "kw") return t.value === "is" || t.value === "not"; // the prefix operators
-    if (t.type === "number" || t.type === "string" ||
+    if (t.type === "number" || t.type === "string" || t.type === "tmpl_start" ||
         t.type === "binding" || t.type === "lparen" || t.type === "caret") return true;
     return t.type === "op" && (t.value === "-" || t.value === "!");
   }
@@ -1242,7 +1250,7 @@ class Parser {
         // { … }` (0.20: the receiver-block sugar stands wherever a value does,
         // `size(children { is checked })`). exists/none/count have no value form
         // and are left to the body's own error.
-        if (expr.kind === "lit") this.fail(`\`${describe(expr)}\` is a literal, not a collection`);
+        if (expr.kind === "lit" || expr.kind === "template") this.fail(`\`${describe(expr)}\` is a literal, not a collection`);
         expr = this.parseConsumerBlock(expr, this.atBlock()!, false);
       } else {
         break; // anything else ends the chain
@@ -1282,6 +1290,7 @@ class Parser {
     }
     if (t.type === "number") { this.next(); return { kind: "lit", span: [t.pos, t.end], value: Number(t.value) }; }
     if (t.type === "string") { this.next(); return { kind: "lit", span: [t.pos, t.end], value: t.value }; }
+    if (t.type === "tmpl_start") return this.parseTemplateLiteral();
     if (t.type === "binding") { this.next(); return this.bindingNode(t); }
     if (t.type === "lparen") {
       this.next();
@@ -1308,6 +1317,39 @@ class Parser {
     }
     this.fail(`unexpected ${this.tokDesc()} — expected a value`);
   }
+
+  // A template literal (GRAMMAR §4, since 0.21): the cursor is at the opening
+  // backtick. The lexer has already split the literal into text runs and `${ … }`
+  // interpolations (with balanced braces, so an interpolation may hold a block
+  // or another template literal); each interpolation holds one full value
+  // expression, read at the current scope depth. `parts` alternates strictly —
+  // text, expression, text, … — with a (possibly empty) text part first and last.
+  private parseTemplateLiteral(): Expr {
+    const open = this.next(); // the backtick
+    const parts: TemplatePart[] = [];
+    let text = "";
+    for (;;) {
+      const t = this.peek();
+      if (t.type === "tmpl_text") { this.next(); text += t.value; continue; }
+      if (t.type === "tmpl_end") { this.next(); break; }
+      if (t.type === "tmpl_interp_start") {
+        this.next();
+        if (this.at("tmpl_interp_end")) {
+          this.failAt(t.pos, "empty interpolation `${}` in a template literal — an interpolation holds an expression (`${name}`)");
+        }
+        const e = this.parseValueExpr();
+        if (!this.at("tmpl_interp_end")) this.fail("expected '}' to close the `${…}` interpolation of a template literal");
+        this.next();
+        parts.push(text, e);
+        text = "";
+        continue;
+      }
+      // Unreachable: the lexer closes every literal it opens or fails.
+      this.fail(`unexpected ${this.tokDesc()} in a template literal`);
+    }
+    parts.push(text);
+    return { kind: "template", span: [open.pos, this.end()], parts };
+  }
 }
 
 // The default key of an unaliased projection item: the last segment of a bare /

package/src/print.ts

@@ -66,7 +66,7 @@ const OR = 1, AND = 2, CMP = 3, RANGE = 4, ADD = 5, MUL = 6, UNARY = 7, POSTFIX
 
 function prec(e: Expr): number {
   switch (e.kind) {
-    case "lit": case "ident": case "outer": case "binding": case "tuple": return PRIMARY;
+    case "lit": case "ident": case "outer": case "binding": case "tuple": case "template": return PRIMARY;
     case "member": case "call": case "required": case "op": return POSTFIX;
     case "unary": return UNARY;
     case "binary": return e.op === "+" || e.op === "-" ? ADD : e.op === "*" || e.op === "/" || e.op === "%" ? MUL : CMP;
@@ -231,6 +231,10 @@ function expr(e: Expr): Out {
       return cat(e.lo ? operand(e.lo, ADD) : "", e.exclusiveEnd ? "..." : "..", e.hi ? operand(e.hi, ADD) : "");
     // A tuple is self-delimiting; its elements are full expressions.
     case "tuple": return cat("(", join(e.items.map(expr), ", "), ")");
+    // A template literal prints as one: its text with the GRAMMAR §1 escapes
+    // (`` \` ``, `\\`, `\$` before a `{`, and the control characters), each
+    // interpolation as `${…}` around the full expression.
+    case "template": return cat("`", ...e.parts.map((p) => (typeof p === "string" ? templateText(p) : cat("${", expr(p), "}"))), "`");
   }
 }
 
@@ -264,13 +268,35 @@ function quote(s: string): string {
   for (const ch of s) {
     switch (ch) {
       case '"': out += '\\"'; break;
-      case "\\": out += "\\\\"; break;
-      case "\n": out += "\\n"; break;
-      case "\t": out += "\\t"; break;
-      case "\r": out += "\\r"; break;
-      case "\0": out += "\\0"; break;
-      default: out += ch;
+      default: out += escapeChar(ch);
     }
   }
   return out + '"';
 }
+
+/** The text of a template literal part, escaped so it re-lexes to itself: the
+ * backtick and the backslash, the control characters as in a string, and a `$`
+ * that a `{` follows (which would otherwise open an interpolation). */
+function templateText(s: string): string {
+  const cps = Array.from(s);
+  let out = "";
+  for (let i = 0; i < cps.length; i++) {
+    const ch = cps[i]!;
+    if (ch === "`") out += "\\`";
+    else if (ch === "$" && cps[i + 1] === "{") out += "\\$";
+    else out += escapeChar(ch);
+  }
+  return out;
+}
+
+/** The escapes a string literal and a template literal share (GRAMMAR §1). */
+function escapeChar(ch: string): string {
+  switch (ch) {
+    case "\\": return "\\\\";
+    case "\n": return "\\n";
+    case "\t": return "\\t";
+    case "\r": return "\\r";
+    case "\0": return "\\0";
+    default: return ch;
+  }
+}

package/src/resolve.ts

@@ -141,6 +141,10 @@ function mapExpr(e: Expr, f: (e: Expr) => Expr | null): Expr {
       const items = mapSame(e.items, go);
       return items === e.items ? e : { ...e, items };
     }
+    case "template": { // the text parts are strings; only the interpolations are expressions
+      const parts = mapSame(e.parts, (p) => (typeof p === "string" ? p : go(p)));
+      return parts === e.parts ? e : { ...e, parts };
+    }
     case "op": { // the receiver is read in this scope; the block is its own scope
       const receiver = go(e.receiver);
       return receiver === e.receiver ? e : { ...e, receiver };

package/src/version.ts

@@ -1,4 +1,4 @@
 /** The OQX language version (`spec/oqx/VERSION`, `major.minor`) this implementation
  * conforms to — distinct from the package's own semver, whose `major.minor` it
  * equals. Stamped on every `toJSON` document. */
-export const LANGUAGE_VERSION = "0.20";
+export const LANGUAGE_VERSION = "0.21";

package/src/walk.ts

@@ -97,9 +97,13 @@ export const CHILDREN: { readonly [K in AstKind]: readonly ChildKey[] } = {
   in: [{ key: "left" }, { key: "right" }],
   range: [{ key: "lo" }, { key: "hi" }],
   tuple: [{ key: "items" }],
+  // The interpolations; the text parts between them are strings, not nodes.
+  template: [{ key: "parts" }],
 };
 
-type Slot = AstNode | AstNode[] | null;
+/** A child slot's value: a node, a list of nodes (a template's `parts` also
+ * holds its text strings, which the walks skip), or `null`. */
+type Slot = AstNode | (AstNode | string)[] | null;
 
 function slot(node: AstNode, key: string): Slot {
   return (node as unknown as Record<string, Slot>)[key] ?? null;
@@ -134,7 +138,7 @@ export function visit(root: AstNode, visitor: Visitor): void {
         if (v === null) continue;
         const c = child.clause ?? clause;
         const d = depth + childDepth(node, child, path);
-        if (Array.isArray(v)) for (const x of v) go(x, c, d);
+        if (Array.isArray(v)) { for (const x of v) if (typeof x !== "string") go(x, c, d); }
         else go(v, c, d);
       }
       path.pop();
@@ -162,7 +166,7 @@ export function transform<T extends Query | Subquery>(root: T, f: (expr: Expr, c
       let next: Slot;
       if (Array.isArray(v)) {
         let changed = false;
-        const mapped = v.map((x) => { const y = go(x, c, d); if (y !== x) changed = true; return y; });
+        const mapped = v.map((x) => { if (typeof x === "string") return x; const y = go(x, c, d); if (y !== x) changed = true; return y; });
         next = changed ? mapped : v;
       } else next = go(v, c, d);
       if (next !== v) out = { ...out, [child.key]: next } as AstNode;