@creationix/rex 0.3.0 → 0.4.1

package/rex-cli.js

@@ -100,12 +100,32 @@ function encodeBareOrLengthString(value) {
     return `${value}:`;
   return `${encodeUint(byteLength(value))},${value}`;
 }
+function splitDecimal(num) {
+  const match = num.toExponential().match(DEC_PARTS);
+  if (!match)
+    throw new Error(`Failed to split decimal for ${num}`);
+  const [, b1, b2 = "", e1] = match;
+  const base = Number.parseInt(b1 + b2, 10);
+  const exp = Number.parseInt(e1, 10) - b2.length;
+  return { base, exp };
+}
+function encodeDecimal(significand, power) {
+  return `${encodeZigzag(power)}*${encodeInt(significand)}`;
+}
 function encodeNumberNode(node) {
   const numberValue = node.value;
-  if (!Number.isFinite(numberValue))
-    throw new Error(`Cannot encode non-finite number: ${node.raw}`);
-  if (Number.isInteger(numberValue))
-    return encodeInt(numberValue);
+  if (Number.isNaN(numberValue))
+    return "nan'";
+  if (numberValue === Infinity)
+    return "inf'";
+  if (numberValue === -Infinity)
+    return "nif'";
+  if (Number.isInteger(numberValue)) {
+    const { base, exp } = splitDecimal(numberValue);
+    if (exp >= 0 && exp <= 4)
+      return encodeInt(numberValue);
+    return encodeDecimal(base, exp);
+  }
   const raw = node.raw.toLowerCase();
   const sign = raw.startsWith("-") ? -1 : 1;
   const unsigned = sign < 0 ? raw.slice(1) : raw;
@@ -128,10 +148,10 @@ function encodeNumberNode(node) {
     significand /= 10;
     power += 1;
   }
-  return `${encodeZigzag(power)}*${encodeInt(significand)}`;
+  return encodeDecimal(significand, power);
 }
 function encodeOpcode(opcode) {
-  return `${encodeUint(OPCODE_IDS[opcode])}%`;
+  return `${OPCODE_IDS[opcode]}%`;
 }
 function encodeCallParts(parts) {
   return `(${parts.join("")})`;
@@ -148,7 +168,7 @@ function addOptionalPrefix(encoded) {
   let payload = encoded;
   if (encoded.startsWith("?(") || encoded.startsWith("!(") || encoded.startsWith("|(") || encoded.startsWith("&(") || encoded.startsWith(">(") || encoded.startsWith("<(") || encoded.startsWith("#(")) {
     payload = encoded.slice(2, -1);
-  } else if (encoded.startsWith(">[") || encoded.startsWith(">{")) {
+  } else if (encoded.startsWith(">[") || encoded.startsWith(">{") || encoded.startsWith("<[") || encoded.startsWith("<{") || encoded.startsWith("#[") || encoded.startsWith("#{")) {
     payload = encoded.slice(2, -1);
   } else if (encoded.startsWith("[") || encoded.startsWith("{") || encoded.startsWith("(")) {
     payload = encoded.slice(1, -1);
@@ -159,7 +179,7 @@ function addOptionalPrefix(encoded) {
 }
 function encodeBlockExpression(block) {
   if (block.length === 0)
-    return "4'";
+    return "un'";
   if (block.length === 1)
     return encodeNode(block[0]);
   return encodeCallParts([encodeOpcode("do"), ...block.map((node) => encodeNode(node))]);
@@ -176,9 +196,13 @@ function encodeConditionalElse(elseBranch) {
   };
   return encodeNode(nested);
 }
+function encodeDomainLookup(shortCode, tag) {
+  return `${shortCode}${tag}`;
+}
 function encodeNavigation(node) {
   const domainRefs = activeEncodeOptions?.domainRefs;
-  if (domainRefs && node.target.type === "identifier") {
+  const domainOpcodes = activeEncodeOptions?.domainOpcodes;
+  if ((domainRefs || domainOpcodes) && node.target.type === "identifier") {
     const staticPath = [node.target.name];
     for (const segment of node.segments) {
       if (segment.type !== "static")
@@ -187,14 +211,17 @@ function encodeNavigation(node) {
     }
     for (let pathLength = staticPath.length;pathLength >= 1; pathLength -= 1) {
       const dottedName = staticPath.slice(0, pathLength).join(".");
-      const domainRef = domainRefs[dottedName];
-      if (domainRef === undefined)
+      const refCode = domainRefs?.[dottedName];
+      const opcodeCode = domainOpcodes?.[dottedName];
+      const shortCode = refCode ?? opcodeCode;
+      if (shortCode === undefined)
         continue;
+      const tag = refCode !== undefined ? "'" : "%";
       const consumedStaticSegments = pathLength - 1;
       if (consumedStaticSegments === node.segments.length) {
-        return `${encodeUint(domainRef)}'`;
+        return encodeDomainLookup(shortCode, tag);
       }
-      const parts2 = [`${encodeUint(domainRef)}'`];
+      const parts2 = [encodeDomainLookup(shortCode, tag)];
       for (const segment of node.segments.slice(consumedStaticSegments)) {
         if (segment.type === "static")
           parts2.push(encodeBareOrLengthString(segment.key));
@@ -220,9 +247,12 @@ function encodeWhile(node) {
 }
 function encodeFor(node) {
   const body = addOptionalPrefix(encodeBlockExpression(node.body));
-  if (node.binding.type === "binding:expr") {
+  if (node.binding.type === "binding:bareIn") {
     return `>(${encodeNode(node.binding.source)}${body})`;
   }
+  if (node.binding.type === "binding:bareOf") {
+    return `<(${encodeNode(node.binding.source)}${body})`;
+  }
   if (node.binding.type === "binding:valueIn") {
     return `>(${encodeNode(node.binding.source)}${node.binding.value}$${body})`;
   }
@@ -233,30 +263,47 @@ function encodeFor(node) {
 }
 function encodeArrayComprehension(node) {
   const body = addOptionalPrefix(encodeNode(node.body));
-  if (node.binding.type === "binding:expr") {
+  if (node.binding.type === "binding:bareIn") {
     return `>[${encodeNode(node.binding.source)}${body}]`;
   }
+  if (node.binding.type === "binding:bareOf") {
+    return `<[${encodeNode(node.binding.source)}${body}]`;
+  }
   if (node.binding.type === "binding:valueIn") {
     return `>[${encodeNode(node.binding.source)}${node.binding.value}$${body}]`;
   }
   if (node.binding.type === "binding:keyValueIn") {
     return `>[${encodeNode(node.binding.source)}${node.binding.key}$${node.binding.value}$${body}]`;
   }
-  return `>[${encodeNode(node.binding.source)}${node.binding.key}$${body}]`;
+  return `<[${encodeNode(node.binding.source)}${node.binding.key}$${body}]`;
 }
 function encodeObjectComprehension(node) {
   const key = addOptionalPrefix(encodeNode(node.key));
   const value = addOptionalPrefix(encodeNode(node.value));
-  if (node.binding.type === "binding:expr") {
+  if (node.binding.type === "binding:bareIn") {
     return `>{${encodeNode(node.binding.source)}${key}${value}}`;
   }
+  if (node.binding.type === "binding:bareOf") {
+    return `<{${encodeNode(node.binding.source)}${key}${value}}`;
+  }
   if (node.binding.type === "binding:valueIn") {
     return `>{${encodeNode(node.binding.source)}${node.binding.value}$${key}${value}}`;
   }
   if (node.binding.type === "binding:keyValueIn") {
     return `>{${encodeNode(node.binding.source)}${node.binding.key}$${node.binding.value}$${key}${value}}`;
   }
-  return `>{${encodeNode(node.binding.source)}${node.binding.key}$${key}${value}}`;
+  return `<{${encodeNode(node.binding.source)}${node.binding.key}$${key}${value}}`;
+}
+function encodeWhileArrayComprehension(node) {
+  const cond = encodeNode(node.condition);
+  const body = addOptionalPrefix(encodeNode(node.body));
+  return `#[${cond}${body}]`;
+}
+function encodeWhileObjectComprehension(node) {
+  const cond = encodeNode(node.condition);
+  const key = addOptionalPrefix(encodeNode(node.key));
+  const value = addOptionalPrefix(encodeNode(node.value));
+  return `#{${cond}${key}${value}}`;
 }
 function encodeNode(node) {
   switch (node.type) {
@@ -265,7 +312,10 @@ function encodeNode(node) {
     case "identifier": {
       const domainRef = activeEncodeOptions?.domainRefs?.[node.name];
       if (domainRef !== undefined)
-        return `${encodeUint(domainRef)}'`;
+        return `${domainRef}'`;
+      const domainOpcode = activeEncodeOptions?.domainOpcodes?.[node.name];
+      if (domainOpcode !== undefined)
+        return `${domainOpcode}%`;
       return `${node.name}$`;
     }
     case "self":
@@ -278,11 +328,11 @@ function encodeNode(node) {
       return `${encodeUint(node.depth - 1)}@`;
     }
     case "boolean":
-      return node.value ? "1'" : "2'";
+      return node.value ? "tr'" : "fl'";
     case "null":
-      return "3'";
+      return "nl'";
     case "undefined":
-      return "4'";
+      return "un'";
     case "number":
       return encodeNumberNode(node);
     case "string":
@@ -293,12 +343,16 @@ function encodeNode(node) {
     }
     case "arrayComprehension":
       return encodeArrayComprehension(node);
+    case "whileArrayComprehension":
+      return encodeWhileArrayComprehension(node);
     case "object": {
       const body = node.entries.map(({ key, value }) => `${encodeNode(key)}${addOptionalPrefix(encodeNode(value))}`).join("");
       return `{${body}}`;
     }
     case "objectComprehension":
       return encodeObjectComprehension(node);
+    case "whileObjectComprehension":
+      return encodeWhileObjectComprehension(node);
     case "key":
       return encodeBareOrLengthString(node.name);
     case "group":
@@ -308,6 +362,10 @@ function encodeNode(node) {
         return `~${encodeNode(node.value)}`;
       if (node.op === "neg")
         return encodeCallParts([encodeOpcode("neg"), encodeNode(node.value)]);
+      if (node.op === "logicalNot") {
+        const val = encodeNode(node.value);
+        return `!(${val}tr')`;
+      }
       return encodeCallParts([encodeOpcode("not"), encodeNode(node.value)]);
     case "binary":
       if (node.op === "and") {
@@ -326,12 +384,19 @@ function encodeNode(node) {
         }).join("");
         return `|(${body})`;
       }
+      if (node.op === "nor") {
+        const left = encodeNode(node.left);
+        const right = addOptionalPrefix(encodeNode(node.right));
+        return `!(${left}${right})`;
+      }
       return encodeCallParts([
         encodeOpcode(BINARY_TO_OPCODE[node.op]),
         encodeNode(node.left),
         encodeNode(node.right)
       ]);
     case "assign": {
+      if (node.op === ":=")
+        return `/${encodeNode(node.place)}${addOptionalPrefix(encodeNode(node.value))}`;
       if (node.op === "=")
         return `=${encodeNode(node.place)}${addOptionalPrefix(encodeNode(node.value))}`;
       const opcode = ASSIGN_COMPOUND_TO_OPCODE[node.op];
@@ -342,8 +407,12 @@ function encodeNode(node) {
     }
     case "navigation":
       return encodeNavigation(node);
-    case "call":
+    case "call": {
+      if (node.callee.type === "identifier" && KEYWORD_OPCODES.has(node.callee.name)) {
+        return encodeCallParts([encodeOpcode(node.callee.name), ...node.args.map((arg) => encodeNode(arg))]);
+      }
       return encodeCallParts([encodeNode(node.callee), ...node.args.map((arg) => encodeNode(arg))]);
+    }
     case "conditional": {
       const opener = node.head === "when" ? "?(" : "!(";
       const cond = encodeNode(node.condition);
@@ -351,6 +420,8 @@ function encodeNode(node) {
       const elseExpr = node.elseBranch ? addOptionalPrefix(encodeConditionalElse(node.elseBranch)) : "";
       return `${opener}${cond}${thenExpr}${elseExpr})`;
     }
+    case "range":
+      return encodeCallParts([encodeOpcode("range"), encodeNode(node.from), encodeNode(node.to)]);
     case "for":
       return encodeFor(node);
     case "while":
@@ -429,6 +500,18 @@ function isPlainObject(value) {
 function isBareKeyName(key) {
   return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(key);
 }
+function isNumericKey(key) {
+  if (key === "")
+    return false;
+  return String(Number(key)) === key && Number.isFinite(Number(key));
+}
+function stringifyKey(key) {
+  if (isBareKeyName(key))
+    return key;
+  if (isNumericKey(key))
+    return key;
+  return stringifyString(key);
+}
 function stringifyString(value) {
   return JSON.stringify(value);
 }
@@ -440,8 +523,12 @@ function stringifyInline(value) {
   if (typeof value === "boolean")
     return value ? "true" : "false";
   if (typeof value === "number") {
-    if (!Number.isFinite(value))
-      throw new Error("Rex stringify() cannot encode non-finite numbers");
+    if (Number.isNaN(value))
+      return "nan";
+    if (value === Infinity)
+      return "inf";
+    if (value === -Infinity)
+      return "-inf";
     return String(value);
   }
   if (typeof value === "string")
@@ -455,7 +542,7 @@ function stringifyInline(value) {
     const entries = Object.entries(value);
     if (entries.length === 0)
       return "{}";
-    const body = entries.map(([key, item]) => `${isBareKeyName(key) ? key : stringifyString(key)}: ${stringifyInline(item)}`).join(" ");
+    const body = entries.map(([key, item]) => `${stringifyKey(key)}: ${stringifyInline(item)}`).join(" ");
     return `{${body}}`;
   }
   throw new Error(`Rex stringify() cannot encode value of type ${typeof value}`);
@@ -492,7 +579,7 @@ ${indent}]`;
     if (entries.length === 0)
       return "{}";
     const lines = entries.map(([key, item]) => {
-      const keyText = isBareKeyName(key) ? key : stringifyString(key);
+      const keyText = stringifyKey(key);
       const rendered = stringifyPretty(item, depth + 1, indentSize, maxWidth);
       return `${childIndent}${keyText}: ${rendered}`;
     });
@@ -510,78 +597,55 @@ function domainRefsFromConfig(config) {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
     throw new Error("Domain config must be an object");
   }
-  const refs = {};
-  for (const section of Object.values(config)) {
-    if (!section || typeof section !== "object" || Array.isArray(section))
-      continue;
-    mapConfigEntries(section, refs);
-  }
-  return refs;
-}
-function decodeDomainRefKey(refText) {
-  if (!refText)
-    throw new Error("Domain ref key cannot be empty");
-  if (!/^[0-9A-Za-z_-]+$/.test(refText)) {
-    throw new Error(`Invalid domain ref key '${refText}' (must use base64 alphabet 0-9a-zA-Z-_)`);
+  const configObj = config;
+  const domainRefs = {};
+  const domainOpcodes = {};
+  const dataSection = configObj.data;
+  if (dataSection && typeof dataSection === "object" && !Array.isArray(dataSection)) {
+    mapConfigEntries(dataSection, domainRefs);
   }
-  if (refText.length > 1 && refText[0] === "0") {
-    throw new Error(`Invalid domain ref key '${refText}' (leading zeroes are not allowed)`);
+  const functionsSection = configObj.functions;
+  if (functionsSection && typeof functionsSection === "object" && !Array.isArray(functionsSection)) {
+    mapConfigEntries(functionsSection, domainOpcodes);
   }
-  if (/^[1-9]$/.test(refText)) {
-    throw new Error(`Invalid domain ref key '${refText}' (reserved by core language)`);
-  }
-  let value = 0;
-  for (const char of refText) {
-    const digit = DOMAIN_DIGIT_INDEX.get(char);
-    if (digit === undefined)
-      throw new Error(`Invalid domain ref key '${refText}'`);
-    value = value * 64 + digit;
-    if (value > Number.MAX_SAFE_INTEGER) {
-      throw new Error(`Invalid domain ref key '${refText}' (must fit in 53 bits)`);
-    }
-  }
-  if (value < FIRST_NON_RESERVED_REF) {
-    throw new Error(`Invalid domain ref key '${refText}' (maps to reserved id ${value})`);
-  }
-  return value;
+  return { domainRefs, domainOpcodes };
 }
 function mapConfigEntries(entries, refs) {
   const sourceKindByRoot = new Map;
   for (const root of Object.keys(refs)) {
     sourceKindByRoot.set(root, "explicit");
   }
-  for (const [refText, rawEntry] of Object.entries(entries)) {
+  for (const [shortCode, rawEntry] of Object.entries(entries)) {
     const entry = rawEntry;
     if (!entry || typeof entry !== "object")
       continue;
     if (!Array.isArray(entry.names))
       continue;
-    const refId = decodeDomainRefKey(refText);
     for (const rawName of entry.names) {
       if (typeof rawName !== "string")
         continue;
-      const existingNameRef = refs[rawName];
-      if (existingNameRef !== undefined && existingNameRef !== refId) {
-        throw new Error(`Conflicting refs for '${rawName}': ${existingNameRef} vs ${refId}`);
+      const existingRef = refs[rawName];
+      if (existingRef !== undefined && existingRef !== shortCode) {
+        throw new Error(`Conflicting refs for '${rawName}': ${existingRef} vs ${shortCode}`);
       }
-      refs[rawName] = refId;
+      refs[rawName] = shortCode;
       const root = rawName.split(".")[0];
       if (!root)
         continue;
       const currentKind = rawName.includes(".") ? "implicit" : "explicit";
       const existing = refs[root];
       if (existing !== undefined) {
-        if (existing === refId)
+        if (existing === shortCode)
           continue;
         const existingKind = sourceKindByRoot.get(root) ?? "explicit";
         if (currentKind === "explicit") {
-          throw new Error(`Conflicting refs for '${root}': ${existing} vs ${refId}`);
+          throw new Error(`Conflicting refs for '${root}': ${existing} vs ${shortCode}`);
         }
         if (existingKind === "explicit")
           continue;
         continue;
       }
-      refs[root] = refId;
+      refs[root] = shortCode;
       sourceKindByRoot.set(root, currentKind);
     }
   }
@@ -863,6 +927,21 @@ function dropBindingNames(env, binding) {
     clearBinding(env, binding.key);
   }
 }
+function optimizeBinding(binding, sourceEnv, currentDepth) {
+  const source = optimizeNode(binding.source, sourceEnv, currentDepth);
+  switch (binding.type) {
+    case "binding:bareIn":
+      return { type: "binding:bareIn", source };
+    case "binding:bareOf":
+      return { type: "binding:bareOf", source };
+    case "binding:valueIn":
+      return { type: "binding:valueIn", value: binding.value, source };
+    case "binding:keyValueIn":
+      return { type: "binding:keyValueIn", key: binding.key, value: binding.value, source };
+    case "binding:keyOf":
+      return { type: "binding:keyOf", key: binding.key, source };
+  }
+}
 function collectReads(node, out) {
   switch (node.type) {
     case "identifier":
@@ -885,11 +964,20 @@ function collectReads(node, out) {
       collectReads(node.binding.source, out);
       collectReads(node.body, out);
       return;
+    case "whileArrayComprehension":
+      collectReads(node.condition, out);
+      collectReads(node.body, out);
+      return;
     case "objectComprehension":
       collectReads(node.binding.source, out);
       collectReads(node.key, out);
       collectReads(node.value, out);
       return;
+    case "whileObjectComprehension":
+      collectReads(node.condition, out);
+      collectReads(node.key, out);
+      collectReads(node.value, out);
+      return;
     case "unary":
       collectReads(node.value, out);
       return;
@@ -926,6 +1014,10 @@ function collectReads(node, out) {
       for (const part of node.body)
         collectReads(part, out);
       return;
+    case "range":
+      collectReads(node.from, out);
+      collectReads(node.to, out);
+      return;
     case "program":
       for (const part of node.body)
         collectReads(part, out);
@@ -970,6 +1062,8 @@ function isPureNode(node) {
       return node.op !== "delete" && isPureNode(node.value);
     case "binary":
       return isPureNode(node.left) && isPureNode(node.right);
+    case "range":
+      return isPureNode(node.from) && isPureNode(node.to);
     default:
       return false;
   }
@@ -1034,6 +1128,8 @@ function hasIdentifierRead(node, name, asPlace = false) {
       return hasIdentifierRead(node.value, name, node.op === "delete");
     case "binary":
       return hasIdentifierRead(node.left, name) || hasIdentifierRead(node.right, name);
+    case "range":
+      return hasIdentifierRead(node.from, name) || hasIdentifierRead(node.to, name);
     case "assign":
       return hasIdentifierRead(node.place, name, true) || hasIdentifierRead(node.value, name);
     default:
@@ -1056,6 +1152,8 @@ function countIdentifierReads(node, name, asPlace = false) {
       return countIdentifierReads(node.value, name, node.op === "delete");
     case "binary":
       return countIdentifierReads(node.left, name) + countIdentifierReads(node.right, name);
+    case "range":
+      return countIdentifierReads(node.from, name) + countIdentifierReads(node.to, name);
     case "assign":
       return countIdentifierReads(node.place, name, true) + countIdentifierReads(node.value, name);
     default:
@@ -1110,6 +1208,12 @@ function replaceIdentifier(node, name, replacement, asPlace = false) {
         place: replaceIdentifier(node.place, name, replacement, true),
         value: replaceIdentifier(node.value, name, replacement)
       };
+    case "range":
+      return {
+        type: "range",
+        from: replaceIdentifier(node.from, name, replacement),
+        to: replaceIdentifier(node.to, name, replacement)
+      };
     default:
       return node;
   }
@@ -1150,7 +1254,16 @@ function inlineAdjacentPureAssignments(block) {
   return out;
 }
 function toNumberNode(value) {
-  return { type: "number", raw: String(value), value };
+  let raw;
+  if (Number.isNaN(value))
+    raw = "nan";
+  else if (value === Infinity)
+    raw = "inf";
+  else if (value === -Infinity)
+    raw = "-inf";
+  else
+    raw = String(value);
+  return { type: "number", raw, value };
 }
 function toStringNode(value) {
   return { type: "string", raw: JSON.stringify(value) };
@@ -1162,7 +1275,7 @@ function toLiteralNode(value) {
     return { type: "null" };
   if (typeof value === "boolean")
     return { type: "boolean", value };
-  if (typeof value === "number" && Number.isFinite(value))
+  if (typeof value === "number")
     return toNumberNode(value);
   if (typeof value === "string")
     return toStringNode(value);
@@ -1245,6 +1358,9 @@ function foldUnary(op, value) {
       return ~value;
     return;
   }
+  if (op === "logicalNot") {
+    return value === undefined ? true : undefined;
+  }
   return;
 }
 function foldBinary(op, left, right) {
@@ -1415,6 +1531,12 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
       }
       return { type: "binary", op: node.op, left, right };
     }
+    case "range":
+      return {
+        type: "range",
+        from: optimizeNode(node.from, env, currentDepth),
+        to: optimizeNode(node.to, env, currentDepth)
+      };
     case "navigation": {
       const target = optimizeNode(node.target, env, currentDepth);
       const segments = node.segments.map((segment) => segment.type === "static" ? segment : { type: "dynamic", key: optimizeNode(segment.key, env, currentDepth) });
@@ -1525,31 +1647,7 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
     }
     case "for": {
       const sourceEnv = cloneOptimizeEnv(env);
-      const binding = (() => {
-        if (node.binding.type === "binding:expr") {
-          return { type: "binding:expr", source: optimizeNode(node.binding.source, sourceEnv, currentDepth) };
-        }
-        if (node.binding.type === "binding:valueIn") {
-          return {
-            type: "binding:valueIn",
-            value: node.binding.value,
-            source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-          };
-        }
-        if (node.binding.type === "binding:keyValueIn") {
-          return {
-            type: "binding:keyValueIn",
-            key: node.binding.key,
-            value: node.binding.value,
-            source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-          };
-        }
-        return {
-          type: "binding:keyOf",
-          key: node.binding.key,
-          source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-        };
-      })();
+      const binding = optimizeBinding(node.binding, sourceEnv, currentDepth);
       const bodyEnv = cloneOptimizeEnv(env);
       dropBindingNames(bodyEnv, binding);
       return {
@@ -1560,20 +1658,7 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
     }
     case "arrayComprehension": {
       const sourceEnv = cloneOptimizeEnv(env);
-      const binding = node.binding.type === "binding:expr" ? { type: "binding:expr", source: optimizeNode(node.binding.source, sourceEnv, currentDepth) } : node.binding.type === "binding:valueIn" ? {
-        type: "binding:valueIn",
-        value: node.binding.value,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      } : node.binding.type === "binding:keyValueIn" ? {
-        type: "binding:keyValueIn",
-        key: node.binding.key,
-        value: node.binding.value,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      } : {
-        type: "binding:keyOf",
-        key: node.binding.key,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      };
+      const binding = optimizeBinding(node.binding, sourceEnv, currentDepth);
       const bodyEnv = cloneOptimizeEnv(env);
       dropBindingNames(bodyEnv, binding);
       return {
@@ -1582,22 +1667,15 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
         body: optimizeNode(node.body, bodyEnv, currentDepth + 1)
       };
     }
+    case "whileArrayComprehension":
+      return {
+        type: "whileArrayComprehension",
+        condition: optimizeNode(node.condition, env, currentDepth),
+        body: optimizeNode(node.body, env, currentDepth + 1)
+      };
     case "objectComprehension": {
       const sourceEnv = cloneOptimizeEnv(env);
-      const binding = node.binding.type === "binding:expr" ? { type: "binding:expr", source: optimizeNode(node.binding.source, sourceEnv, currentDepth) } : node.binding.type === "binding:valueIn" ? {
-        type: "binding:valueIn",
-        value: node.binding.value,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      } : node.binding.type === "binding:keyValueIn" ? {
-        type: "binding:keyValueIn",
-        key: node.binding.key,
-        value: node.binding.value,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      } : {
-        type: "binding:keyOf",
-        key: node.binding.key,
-        source: optimizeNode(node.binding.source, sourceEnv, currentDepth)
-      };
+      const binding = optimizeBinding(node.binding, sourceEnv, currentDepth);
       const bodyEnv = cloneOptimizeEnv(env);
       dropBindingNames(bodyEnv, binding);
       return {
@@ -1607,6 +1685,13 @@ function optimizeNode(node, env, currentDepth, asPlace = false) {
         value: optimizeNode(node.value, bodyEnv, currentDepth + 1)
       };
     }
+    case "whileObjectComprehension":
+      return {
+        type: "whileObjectComprehension",
+        condition: optimizeNode(node.condition, env, currentDepth),
+        key: optimizeNode(node.key, env, currentDepth + 1),
+        value: optimizeNode(node.value, env, currentDepth + 1)
+      };
     default:
       return node;
   }
@@ -1658,6 +1743,10 @@ function collectLocalBindings(node, locals) {
       collectLocalBindings(node.left, locals);
       collectLocalBindings(node.right, locals);
       return;
+    case "range":
+      collectLocalBindings(node.from, locals);
+      collectLocalBindings(node.to, locals);
+      return;
     case "conditional":
       collectLocalBindings(node.condition, locals);
       for (const part of node.thenBlock)
@@ -1674,11 +1763,20 @@ function collectLocalBindings(node, locals) {
       collectLocalBindingFromBinding(node.binding, locals);
       collectLocalBindings(node.body, locals);
       return;
+    case "whileArrayComprehension":
+      collectLocalBindings(node.condition, locals);
+      collectLocalBindings(node.body, locals);
+      return;
     case "objectComprehension":
       collectLocalBindingFromBinding(node.binding, locals);
       collectLocalBindings(node.key, locals);
       collectLocalBindings(node.value, locals);
       return;
+    case "whileObjectComprehension":
+      collectLocalBindings(node.condition, locals);
+      collectLocalBindings(node.key, locals);
+      collectLocalBindings(node.value, locals);
+      return;
     default:
       return;
   }
@@ -1770,6 +1868,10 @@ function collectNameFrequencies(node, locals, frequencies, order, nextOrder) {
       collectNameFrequencies(node.left, locals, frequencies, order, nextOrder);
       collectNameFrequencies(node.right, locals, frequencies, order, nextOrder);
       return;
+    case "range":
+      collectNameFrequencies(node.from, locals, frequencies, order, nextOrder);
+      collectNameFrequencies(node.to, locals, frequencies, order, nextOrder);
+      return;
     case "conditional":
       collectNameFrequencies(node.condition, locals, frequencies, order, nextOrder);
       for (const part of node.thenBlock)
@@ -1786,11 +1888,20 @@ function collectNameFrequencies(node, locals, frequencies, order, nextOrder) {
       collectNameFrequenciesBinding(node.binding, locals, frequencies, order, nextOrder);
       collectNameFrequencies(node.body, locals, frequencies, order, nextOrder);
       return;
+    case "whileArrayComprehension":
+      collectNameFrequencies(node.condition, locals, frequencies, order, nextOrder);
+      collectNameFrequencies(node.body, locals, frequencies, order, nextOrder);
+      return;
     case "objectComprehension":
       collectNameFrequenciesBinding(node.binding, locals, frequencies, order, nextOrder);
       collectNameFrequencies(node.key, locals, frequencies, order, nextOrder);
       collectNameFrequencies(node.value, locals, frequencies, order, nextOrder);
       return;
+    case "whileObjectComprehension":
+      collectNameFrequencies(node.condition, locals, frequencies, order, nextOrder);
+      collectNameFrequencies(node.key, locals, frequencies, order, nextOrder);
+      collectNameFrequencies(node.value, locals, frequencies, order, nextOrder);
+      return;
     default:
       return;
   }
@@ -1865,6 +1976,12 @@ function renameLocalNames(node, map) {
         left: renameLocalNames(node.left, map),
         right: renameLocalNames(node.right, map)
       };
+    case "range":
+      return {
+        type: "range",
+        from: renameLocalNames(node.from, map),
+        to: renameLocalNames(node.to, map)
+      };
     case "assign": {
       const place = node.place.type === "identifier" && map.has(node.place.name) ? { type: "identifier", name: map.get(node.place.name) } : renameLocalNames(node.place, map);
       return {
@@ -1894,6 +2011,12 @@ function renameLocalNames(node, map) {
         binding: renameLocalNamesBinding(node.binding, map),
         body: renameLocalNames(node.body, map)
       };
+    case "whileArrayComprehension":
+      return {
+        type: "whileArrayComprehension",
+        condition: renameLocalNames(node.condition, map),
+        body: renameLocalNames(node.body, map)
+      };
     case "objectComprehension":
       return {
         type: "objectComprehension",
@@ -1901,34 +2024,31 @@ function renameLocalNames(node, map) {
         key: renameLocalNames(node.key, map),
         value: renameLocalNames(node.value, map)
       };
+    case "whileObjectComprehension":
+      return {
+        type: "whileObjectComprehension",
+        condition: renameLocalNames(node.condition, map),
+        key: renameLocalNames(node.key, map),
+        value: renameLocalNames(node.value, map)
+      };
     default:
       return node;
   }
 }
 function renameLocalNamesBinding(binding, map) {
-  if (binding.type === "binding:expr") {
-    return { type: "binding:expr", source: renameLocalNames(binding.source, map) };
+  const source = renameLocalNames(binding.source, map);
+  switch (binding.type) {
+    case "binding:bareIn":
+      return { type: "binding:bareIn", source };
+    case "binding:bareOf":
+      return { type: "binding:bareOf", source };
+    case "binding:valueIn":
+      return { type: "binding:valueIn", value: map.get(binding.value) ?? binding.value, source };
+    case "binding:keyValueIn":
+      return { type: "binding:keyValueIn", key: map.get(binding.key) ?? binding.key, value: map.get(binding.value) ?? binding.value, source };
+    case "binding:keyOf":
+      return { type: "binding:keyOf", key: map.get(binding.key) ?? binding.key, source };
   }
-  if (binding.type === "binding:valueIn") {
-    return {
-      type: "binding:valueIn",
-      value: map.get(binding.value) ?? binding.value,
-      source: renameLocalNames(binding.source, map)
-    };
-  }
-  if (binding.type === "binding:keyValueIn") {
-    return {
-      type: "binding:keyValueIn",
-      key: map.get(binding.key) ?? binding.key,
-      value: map.get(binding.value) ?? binding.value,
-      source: renameLocalNames(binding.source, map)
-    };
-  }
-  return {
-    type: "binding:keyOf",
-    key: map.get(binding.key) ?? binding.key,
-    source: renameLocalNames(binding.source, map)
-  };
 }
 function renameLocalNamesElse(elseBranch, map) {
   if (elseBranch.type === "else") {
@@ -1975,14 +2095,20 @@ function compile(source, options) {
   let lowered = options?.optimize ? optimizeIR(ir) : ir;
   if (options?.minifyNames)
     lowered = minifyLocalNamesIR(lowered);
-  const domainRefs = options?.domainConfig ? domainRefsFromConfig(options.domainConfig) : undefined;
+  const domainMaps = options?.domainConfig ? domainRefsFromConfig(options.domainConfig) : undefined;
   return encodeIR(lowered, {
-    domainRefs,
+    ...domainMaps,
     dedupeValues: options?.dedupeValues,
     dedupeMinBytes: options?.dedupeMinBytes
   });
 }
 function parseNumber(raw) {
+  if (raw === "nan")
+    return NaN;
+  if (raw === "inf")
+    return Infinity;
+  if (raw === "-inf")
+    return -Infinity;
   if (/^-?0x/i.test(raw))
     return parseInt(raw, 16);
   if (/^-?0b/i.test(raw)) {
@@ -2054,7 +2180,7 @@ function buildPostfix(base, steps) {
   flushSegments();
   return current;
 }
-var require2, rexGrammarModule, rexGrammar, grammar, semantics, DIGITS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_", OPCODE_IDS, FIRST_NON_RESERVED_REF = 5, DOMAIN_DIGIT_INDEX, BINARY_TO_OPCODE, ASSIGN_COMPOUND_TO_OPCODE, activeEncodeOptions, DIGIT_SET, DIGIT_INDEX;
+var require2, rexGrammarModule, rexGrammar, grammar, semantics, DIGITS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_", OPCODE_IDS, KEYWORD_OPCODES, BINARY_TO_OPCODE, ASSIGN_COMPOUND_TO_OPCODE, DEC_PARTS, activeEncodeOptions, DIGIT_SET, DIGIT_INDEX;
 var init_rex = __esm(() => {
   require2 = createRequire(import.meta.url);
   rexGrammarModule = require2("./rex.ohm-bundle.cjs");
@@ -2062,30 +2188,32 @@ var init_rex = __esm(() => {
   grammar = rexGrammar;
   semantics = rexGrammar.createSemantics();
   OPCODE_IDS = {
-    do: 0,
-    add: 1,
-    sub: 2,
-    mul: 3,
-    div: 4,
-    eq: 5,
-    neq: 6,
-    lt: 7,
-    lte: 8,
-    gt: 9,
-    gte: 10,
-    and: 11,
-    or: 12,
-    xor: 13,
-    not: 14,
-    boolean: 15,
-    number: 16,
-    string: 17,
-    array: 18,
-    object: 19,
-    mod: 20,
-    neg: 21
+    do: "",
+    add: "ad",
+    sub: "sb",
+    mul: "ml",
+    div: "dv",
+    eq: "eq",
+    neq: "nq",
+    lt: "lt",
+    lte: "le",
+    gt: "gt",
+    gte: "ge",
+    and: "an",
+    or: "or",
+    xor: "xr",
+    not: "nt",
+    boolean: "bt",
+    number: "nm",
+    string: "st",
+    array: "ar",
+    object: "ob",
+    mod: "md",
+    neg: "ng",
+    range: "rn",
+    size: "sz"
   };
-  DOMAIN_DIGIT_INDEX = new Map(Array.from(DIGITS).map((char, index) => [char, index]));
+  KEYWORD_OPCODES = new Set(["boolean", "number", "string", "array", "object", "size"]);
   BINARY_TO_OPCODE = {
     add: "add",
     sub: "sub",
@@ -2114,6 +2242,7 @@ var init_rex = __esm(() => {
     "|=": "or",
     "^=": "xor"
   };
+  DEC_PARTS = /^(-?\d)(?:\.(\d+))?e([+-]\d+)$/;
   DIGIT_SET = new Set(DIGITS.split(""));
   DIGIT_INDEX = new Map(Array.from(DIGITS).map((char, index) => [char, index]));
   semantics.addOperation("toIR", {
@@ -2159,6 +2288,9 @@ var init_rex = __esm(() => {
     ExistenceExpr_or(left, _or, right) {
       return { type: "binary", op: "or", left: left.toIR(), right: right.toIR() };
     },
+    ExistenceExpr_nor(left, _nor, right) {
+      return { type: "binary", op: "nor", left: left.toIR(), right: right.toIR() };
+    },
     BitExpr_and(left, _op, right) {
       return { type: "binary", op: "bitAnd", left: left.toIR(), right: right.toIR() };
     },
@@ -2168,6 +2300,9 @@ var init_rex = __esm(() => {
     BitExpr_or(left, _op, right) {
       return { type: "binary", op: "bitOr", left: left.toIR(), right: right.toIR() };
     },
+    RangeExpr_range(left, _op, right) {
+      return { type: "range", from: left.toIR(), to: right.toIR() };
+    },
     CompareExpr_binary(left, op, right) {
       const map = {
         "==": "eq",
@@ -2208,6 +2343,9 @@ var init_rex = __esm(() => {
     UnaryExpr_not(_op, value) {
       return { type: "unary", op: "not", value: value.toIR() };
     },
+    UnaryExpr_logicalNot(_not, value) {
+      return { type: "unary", op: "logicalNot", value: value.toIR() };
+    },
     UnaryExpr_delete(_del, place) {
       return { type: "unary", op: "delete", value: place.toIR() };
     },
@@ -2261,14 +2399,6 @@ var init_rex = __esm(() => {
     ConditionalElse_else(_else, block) {
       return { type: "else", block: block.toIR() };
     },
-    DoExpr(_do, block, _end) {
-      const body = block.toIR();
-      if (body.length === 0)
-        return { type: "undefined" };
-      if (body.length === 1)
-        return body[0];
-      return { type: "program", body };
-    },
     WhileExpr(_while, condition, _do, block, _end) {
       return {
         type: "while",
@@ -2283,30 +2413,44 @@ var init_rex = __esm(() => {
         body: block.toIR()
       };
     },
-    BindingExpr(iterOrExpr) {
-      const node = iterOrExpr.toIR();
-      if (typeof node === "object" && node && "type" in node && String(node.type).startsWith("binding:")) {
-        return node;
-      }
-      return { type: "binding:expr", source: node };
-    },
     Array_empty(_open, _close) {
       return { type: "array", items: [] };
     },
-    Array_comprehension(_open, binding, _semi, body, _close) {
+    Array_forComprehension(_open, body, _for, binding, _close) {
       return {
         type: "arrayComprehension",
         binding: binding.toIR(),
         body: body.toIR()
       };
     },
+    Array_whileComprehension(_open, body, _while, condition, _close) {
+      return {
+        type: "whileArrayComprehension",
+        condition: condition.toIR(),
+        body: body.toIR()
+      };
+    },
+    Array_inComprehension(_open, body, _in, source, _close) {
+      return {
+        type: "arrayComprehension",
+        binding: { type: "binding:bareIn", source: source.toIR() },
+        body: body.toIR()
+      };
+    },
+    Array_ofComprehension(_open, body, _of, source, _close) {
+      return {
+        type: "arrayComprehension",
+        binding: { type: "binding:bareOf", source: source.toIR() },
+        body: body.toIR()
+      };
+    },
     Array_values(_open, items, _close) {
       return { type: "array", items: normalizeList(items.toIR()) };
     },
     Object_empty(_open, _close) {
       return { type: "object", entries: [] };
     },
-    Object_comprehension(_open, binding, _semi, key, _colon, value, _close) {
+    Object_forComprehension(_open, key, _colon, value, _for, binding, _close) {
       return {
         type: "objectComprehension",
         binding: binding.toIR(),
@@ -2314,6 +2458,30 @@ var init_rex = __esm(() => {
         value: value.toIR()
       };
     },
+    Object_whileComprehension(_open, key, _colon, value, _while, condition, _close) {
+      return {
+        type: "whileObjectComprehension",
+        condition: condition.toIR(),
+        key: key.toIR(),
+        value: value.toIR()
+      };
+    },
+    Object_inComprehension(_open, key, _colon, value, _in, source, _close) {
+      return {
+        type: "objectComprehension",
+        binding: { type: "binding:bareIn", source: source.toIR() },
+        key: key.toIR(),
+        value: value.toIR()
+      };
+    },
+    Object_ofComprehension(_open, key, _colon, value, _of, source, _close) {
+      return {
+        type: "objectComprehension",
+        binding: { type: "binding:bareOf", source: source.toIR() },
+        key: key.toIR(),
+        value: value.toIR()
+      };
+    },
     Object_pairs(_open, pairs, _close) {
       return {
         type: "object",
@@ -2342,6 +2510,18 @@ var init_rex = __esm(() => {
         source: source.toIR()
       };
     },
+    IterBinding_bareIn(_in, source) {
+      return {
+        type: "binding:bareIn",
+        source: source.toIR()
+      };
+    },
+    IterBinding_bareOf(_of, source) {
+      return {
+        type: "binding:bareOf",
+        source: source.toIR()
+      };
+    },
     Pair(key, _colon, value) {
       return { key: key.toIR(), value: value.toIR() };
     },
@@ -2405,6 +2585,9 @@ var init_rex = __esm(() => {
     BooleanKw(_kw) {
       return { type: "identifier", name: "boolean" };
     },
+    SizeKw(_kw) {
+      return { type: "identifier", name: "size" };
+    },
     identifier(_a, _b) {
       return { type: "identifier", name: this.sourceString };
     },
@@ -2443,7 +2626,6 @@ class CursorInterpreter {
   pos = 0;
   state;
   selfStack;
-  opcodeMarkers;
   pointerCache = new Map;
   gasLimit;
   gas = 0;
@@ -2458,25 +2640,22 @@ class CursorInterpreter {
     this.state = {
       vars: ctx.vars ?? {},
       refs: {
-        0: ctx.refs?.[0],
-        1: ctx.refs?.[1] ?? true,
-        2: ctx.refs?.[2] ?? false,
-        3: ctx.refs?.[3] ?? null,
-        4: ctx.refs?.[4] ?? undefined
+        tr: true,
+        fl: false,
+        nl: null,
+        un: undefined,
+        nan: NaN,
+        inf: Infinity,
+        nif: -Infinity,
+        ...ctx.refs
       }
     };
     this.selfStack = ctx.selfStack && ctx.selfStack.length > 0 ? [...ctx.selfStack] : [initialSelf];
     this.gasLimit = ctx.gasLimit ?? 0;
-    this.opcodeMarkers = Array.from({ length: 256 }, (_, id) => ({ __opcode: id }));
-    for (const [idText, value] of Object.entries(ctx.refs ?? {})) {
-      const id = Number(idText);
-      if (Number.isInteger(id))
-        this.state.refs[id] = value;
-    }
     if (ctx.opcodes) {
-      for (const [idText, op] of Object.entries(ctx.opcodes)) {
+      for (const [key, op] of Object.entries(ctx.opcodes)) {
         if (op)
-          this.customOpcodes.set(Number(idText), op);
+          this.customOpcodes.set(key, op);
       }
     }
   }
@@ -2537,6 +2716,22 @@ class CursorInterpreter {
     const end = this.pos;
     return { start, end, value: decodePrefix(this.text, start, end), raw: this.text.slice(start, end) };
   }
+  advanceByBytes(start, byteCount) {
+    if (byteCount <= 0)
+      return start;
+    let bytes = 0;
+    let index = start;
+    for (const char of this.text.slice(start)) {
+      const charBytes = Buffer.byteLength(char);
+      if (bytes + charBytes > byteCount)
+        break;
+      bytes += charBytes;
+      index += char.length;
+      if (bytes === byteCount)
+        return index;
+    }
+    throw new Error("String container overflows input");
+  }
   ensure(char) {
     if (this.text[this.pos] !== char)
       throw new Error(`Expected '${char}' at ${this.pos}`);
@@ -2577,36 +2772,34 @@ class CursorInterpreter {
         const significand = this.evalValue();
         if (typeof significand !== "number")
           throw new Error("Decimal significand must be numeric");
-        return significand * 10 ** power;
+        return parseFloat(`${significand}e${power}`);
       }
       case ":":
         this.pos += 1;
         return prefix.raw;
       case "%":
         this.pos += 1;
-        return this.opcodeMarkers[prefix.value] ?? { __opcode: prefix.value };
+        return { __opcode: prefix.raw };
       case "@":
         this.pos += 1;
         return this.readSelf(prefix.value);
       case "'":
         this.pos += 1;
-        return this.state.refs[prefix.value];
+        return this.state.refs[prefix.raw];
       case "$":
         this.pos += 1;
         return this.state.vars[prefix.raw];
       case ",": {
         this.pos += 1;
         const start = this.pos;
-        const end = start + prefix.value;
-        if (end > this.text.length)
-          throw new Error("String container overflows input");
+        const end = this.advanceByBytes(start, prefix.value);
         const value = this.text.slice(start, end);
         this.pos = end;
         return value;
       }
       case "^": {
         this.pos += 1;
-        const target = this.pos + prefix.value;
+        const target = this.advanceByBytes(this.pos, prefix.value);
         if (this.pointerCache.has(target))
           return this.pointerCache.get(target);
         const save = this.pos;
@@ -2623,6 +2816,14 @@ class CursorInterpreter {
         this.writePlace(place, value);
         return value;
       }
+      case "/": {
+        this.pos += 1;
+        const place = this.readPlace();
+        const oldValue = this.readPlaceValue(place);
+        const newValue = this.evalValue();
+        this.writePlace(place, newValue);
+        return oldValue;
+      }
       case "~": {
         this.pos += 1;
         const place = this.readPlace();
@@ -2650,7 +2851,7 @@ class CursorInterpreter {
       case "<":
         return this.evalLoopLike(tag);
       case "#":
-        return this.evalWhileLoop();
+        return this.evalWhileLike();
       default:
         throw new Error(`Unexpected tag '${tag}' at ${this.pos}`);
     }
@@ -2863,15 +3064,11 @@ class CursorInterpreter {
         return entries.map(([key]) => ({ key, value: key }));
       return entries.map(([key, value]) => ({ key, value }));
     }
-    if (typeof iterable === "number" && Number.isFinite(iterable) && iterable > 0) {
-      const out = [];
-      for (let index = 0;index < Math.floor(iterable); index += 1) {
-        if (keysOnly)
-          out.push({ key: index, value: index });
-        else
-          out.push({ key: index, value: index + 1 });
-      }
-      return out;
+    if (typeof iterable === "string") {
+      const entries = Array.from(iterable);
+      if (keysOnly)
+        return entries.map((_value, index) => ({ key: index, value: index }));
+      return entries.map((value, index) => ({ key: index, value }));
     }
     return [];
   }
@@ -2916,21 +3113,32 @@ class CursorInterpreter {
     }
     return last;
   }
-  evalWhileLoop() {
+  evalWhileLike() {
+    this.pos += 1;
+    const open = this.text[this.pos];
+    if (!open || !"([{".includes(open))
+      throw new Error(`Expected opener after '#' at ${this.pos}`);
+    const close = open === "(" ? ")" : open === "[" ? "]" : "}";
     this.pos += 1;
-    this.ensure("(");
     const condStart = this.pos;
     const condValue = this.evalValue();
     const bodyStart = this.pos;
-    const bodyValueCount = 1;
+    const bodyValueCount = open === "{" ? 2 : 1;
     let cursor = bodyStart;
     for (let index = 0;index < bodyValueCount; index += 1) {
       cursor = this.skipValueFrom(cursor);
     }
     const bodyEnd = cursor;
     this.pos = bodyEnd;
-    this.ensure(")");
+    this.ensure(close);
     const afterClose = this.pos;
+    if (open === "[")
+      return this.evalWhileArrayComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue);
+    if (open === "{")
+      return this.evalWhileObjectComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue);
+    return this.evalWhileLoop(condStart, bodyStart, bodyEnd, afterClose, condValue);
+  }
+  evalWhileLoop(condStart, bodyStart, bodyEnd, afterClose, condValue) {
     let last = undefined;
     let currentCond = condValue;
     while (isDefined(currentCond)) {
@@ -2951,6 +3159,58 @@ class CursorInterpreter {
     this.pos = afterClose;
     return last;
   }
+  evalWhileArrayComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue) {
+    const out = [];
+    let currentCond = condValue;
+    while (isDefined(currentCond)) {
+      this.tick();
+      this.selfStack.push(currentCond);
+      const value = this.evalBodySlice(bodyStart, bodyEnd);
+      this.selfStack.pop();
+      const control = this.handleLoopControl(value);
+      if (control) {
+        if (control.depth > 1)
+          return { kind: control.kind, depth: control.depth - 1 };
+        if (control.kind === "break")
+          break;
+        currentCond = this.evalBodySlice(condStart, bodyStart);
+        continue;
+      }
+      if (isDefined(value))
+        out.push(value);
+      currentCond = this.evalBodySlice(condStart, bodyStart);
+    }
+    this.pos = afterClose;
+    return out;
+  }
+  evalWhileObjectComprehension(condStart, bodyStart, bodyEnd, afterClose, condValue) {
+    const result = {};
+    let currentCond = condValue;
+    while (isDefined(currentCond)) {
+      this.tick();
+      this.selfStack.push(currentCond);
+      const save = this.pos;
+      this.pos = bodyStart;
+      const key = this.evalValue();
+      const value = this.evalValue();
+      this.pos = save;
+      this.selfStack.pop();
+      const control = this.handleLoopControl(value);
+      if (control) {
+        if (control.depth > 1)
+          return { kind: control.kind, depth: control.depth - 1 };
+        if (control.kind === "break")
+          break;
+        currentCond = this.evalBodySlice(condStart, bodyStart);
+        continue;
+      }
+      if (isDefined(value))
+        result[String(key)] = value;
+      currentCond = this.evalBodySlice(condStart, bodyStart);
+    }
+    this.pos = afterClose;
+    return result;
+  }
   evalArrayComprehension(iterable, varA, varB, bodyStart, bodyEnd, keysOnly) {
     const items = this.iterate(iterable, keysOnly);
     const out = [];
@@ -3019,25 +3279,39 @@ class CursorInterpreter {
       case OPCODES.do:
         return args.length ? args[args.length - 1] : undefined;
       case OPCODES.add:
+        if (args[0] === undefined || args[1] === undefined)
+          return;
         if (typeof args[0] === "string" || typeof args[1] === "string") {
-          return String(args[0] ?? "") + String(args[1] ?? "");
+          return String(args[0]) + String(args[1]);
         }
-        return Number(args[0] ?? 0) + Number(args[1] ?? 0);
+        return Number(args[0]) + Number(args[1]);
       case OPCODES.sub:
-        return Number(args[0] ?? 0) - Number(args[1] ?? 0);
+        if (args[0] === undefined || args[1] === undefined)
+          return;
+        return Number(args[0]) - Number(args[1]);
       case OPCODES.mul:
-        return Number(args[0] ?? 0) * Number(args[1] ?? 0);
+        if (args[0] === undefined || args[1] === undefined)
+          return;
+        return Number(args[0]) * Number(args[1]);
       case OPCODES.div:
-        return Number(args[0] ?? 0) / Number(args[1] ?? 0);
+        if (args[0] === undefined || args[1] === undefined)
+          return;
+        return Number(args[0]) / Number(args[1]);
       case OPCODES.mod:
-        return Number(args[0] ?? 0) % Number(args[1] ?? 0);
+        if (args[0] === undefined || args[1] === undefined)
+          return;
+        return Number(args[0]) % Number(args[1]);
       case OPCODES.neg:
-        return -Number(args[0] ?? 0);
+        if (args[0] === undefined)
+          return;
+        return -Number(args[0]);
       case OPCODES.not: {
         const value = args[0];
+        if (value === undefined)
+          return;
         if (typeof value === "boolean")
           return !value;
-        return ~Number(value ?? 0);
+        return ~Number(value);
       }
       case OPCODES.and: {
         const [a, b] = args;
@@ -3079,6 +3353,25 @@ class CursorInterpreter {
         return Array.isArray(args[0]) ? args[0] : undefined;
       case OPCODES.object:
         return args[0] && typeof args[0] === "object" && !Array.isArray(args[0]) ? args[0] : undefined;
+      case OPCODES.range: {
+        const from = Number(args[0]);
+        const to = Number(args[1]);
+        const step = to >= from ? 1 : -1;
+        const out = [];
+        for (let v = from;step > 0 ? v <= to : v >= to; v += step)
+          out.push(v);
+        return out;
+      }
+      case OPCODES.size: {
+        const target = args[0];
+        if (Array.isArray(target))
+          return target.length;
+        if (typeof target === "string")
+          return Array.from(target).length;
+        if (target && typeof target === "object")
+          return Object.keys(target).length;
+        return;
+      }
       default:
         throw new Error(`Unknown opcode ${id}`);
     }
@@ -3088,10 +3381,59 @@ class CursorInterpreter {
     for (const key of keys) {
       if (current === undefined || current === null)
         return;
-      current = current[String(key)];
+      current = this.readProperty(current, key);
+      if (current === undefined)
+        return;
     }
     return current;
   }
+  readProperty(target, key) {
+    const index = this.parseIndexKey(key);
+    if (Array.isArray(target)) {
+      if (index === undefined)
+        return;
+      return target[index];
+    }
+    if (typeof target === "string") {
+      if (index === undefined)
+        return;
+      return Array.from(target)[index];
+    }
+    if (this.isPlainObject(target)) {
+      const prop = String(key);
+      if (!Object.prototype.hasOwnProperty.call(target, prop))
+        return;
+      return target[prop];
+    }
+    return;
+  }
+  canWriteProperty(target, key) {
+    const index = this.parseIndexKey(key);
+    if (Array.isArray(target)) {
+      if (index === undefined)
+        return;
+      return { kind: "array", index };
+    }
+    if (this.isPlainObject(target))
+      return { kind: "object" };
+    return;
+  }
+  parseIndexKey(key) {
+    if (typeof key === "number" && Number.isInteger(key) && key >= 0)
+      return key;
+    if (typeof key !== "string" || key.length === 0)
+      return;
+    if (!/^(0|[1-9]\d*)$/.test(key))
+      return;
+    const index = Number(key);
+    return Number.isSafeInteger(index) ? index : undefined;
+  }
+  isPlainObject(value) {
+    if (!value || typeof value !== "object")
+      return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+  }
   readPlace() {
     this.skipNonCode();
     const direct = this.readRootVarOrRefIfPresent();
@@ -3146,13 +3488,13 @@ class CursorInterpreter {
     }
     this.pos += 1;
     return {
-      root: tag === "$" ? prefix.raw : prefix.value,
+      root: prefix.raw,
       isRef: tag === "'"
     };
   }
   writePlace(place, value) {
     const rootTable = place.isRef ? this.state.refs : this.state.vars;
-    const rootKey = String(place.root);
+    const rootKey = place.root;
     if (place.keys.length === 0) {
       rootTable[rootKey] = value;
       return;
@@ -3163,17 +3505,48 @@ class CursorInterpreter {
       rootTable[rootKey] = target;
     }
     for (let index = 0;index < place.keys.length - 1; index += 1) {
-      const key = String(place.keys[index]);
-      const next = target[key];
+      const key = place.keys[index];
+      const access2 = this.canWriteProperty(target, key);
+      if (!access2)
+        return;
+      if (access2.kind === "array") {
+        const next2 = target[access2.index];
+        if (!next2 || typeof next2 !== "object")
+          target[access2.index] = {};
+        target = target[access2.index];
+        continue;
+      }
+      const prop = String(key);
+      const next = target[prop];
       if (!next || typeof next !== "object")
-        target[key] = {};
-      target = target[key];
+        target[prop] = {};
+      target = target[prop];
     }
-    target[String(place.keys[place.keys.length - 1])] = value;
+    const lastKey = place.keys[place.keys.length - 1];
+    const access = this.canWriteProperty(target, lastKey);
+    if (!access)
+      return;
+    if (access.kind === "array") {
+      target[access.index] = value;
+      return;
+    }
+    target[String(lastKey)] = value;
+  }
+  readPlaceValue(place) {
+    const rootTable = place.isRef ? this.state.refs : this.state.vars;
+    let current = rootTable[place.root];
+    for (const key of place.keys) {
+      if (current === undefined || current === null)
+        return;
+      current = this.readProperty(current, key);
+      if (current === undefined)
+        return;
+    }
+    return current;
   }
   deletePlace(place) {
     const rootTable = place.isRef ? this.state.refs : this.state.vars;
-    const rootKey = String(place.root);
+    const rootKey = place.root;
     if (place.keys.length === 0) {
       delete rootTable[rootKey];
       return;
@@ -3182,11 +3555,29 @@ class CursorInterpreter {
     if (!target || typeof target !== "object")
       return;
     for (let index = 0;index < place.keys.length - 1; index += 1) {
-      target = target[String(place.keys[index])];
+      const key = place.keys[index];
+      const access2 = this.canWriteProperty(target, key);
+      if (!access2)
+        return;
+      if (access2.kind === "array") {
+        target = target[access2.index];
+        if (!target || typeof target !== "object")
+          return;
+        continue;
+      }
+      target = target[String(key)];
       if (!target || typeof target !== "object")
         return;
     }
-    delete target[String(place.keys[place.keys.length - 1])];
+    const lastKey = place.keys[place.keys.length - 1];
+    const access = this.canWriteProperty(target, lastKey);
+    if (!access)
+      return;
+    if (access.kind === "array") {
+      delete target[access.index];
+      return;
+    }
+    delete target[String(lastKey)];
   }
   skipValue() {
     this.pos = this.skipValueFrom(this.pos);
@@ -3202,12 +3593,12 @@ class CursorInterpreter {
       return startPos;
     }
     if (tag === ",") {
-      this.pos += 1 + prefix.value;
+      this.pos = this.advanceByBytes(this.pos + 1, prefix.value);
       const end2 = this.pos;
       this.pos = save;
       return end2;
     }
-    if (tag === "=") {
+    if (tag === "=" || tag === "/") {
       this.pos += 1;
       this.skipValue();
       this.skipValue();
@@ -3242,7 +3633,8 @@ class CursorInterpreter {
     if (opener && "([{".includes(opener)) {
       const close = opener === "(" ? ")" : opener === "[" ? "]" : "}";
       if (prefix.value > 0) {
-        this.pos += 1 + prefix.value + 1;
+        const bodyEnd = this.advanceByBytes(this.pos + 1, prefix.value);
+        this.pos = bodyEnd + 1;
         const end3 = this.pos;
         this.pos = save;
         return end3;
@@ -3278,28 +3670,30 @@ var init_rexc_interpreter = __esm(() => {
   init_rex();
   digitMap = new Map(Array.from(DIGITS2).map((char, index) => [char, index]));
   OPCODES = {
-    do: 0,
-    add: 1,
-    sub: 2,
-    mul: 3,
-    div: 4,
-    eq: 5,
-    neq: 6,
-    lt: 7,
-    lte: 8,
-    gt: 9,
-    gte: 10,
-    and: 11,
-    or: 12,
-    xor: 13,
-    not: 14,
-    boolean: 15,
-    number: 16,
-    string: 17,
-    array: 18,
-    object: 19,
-    mod: 20,
-    neg: 21
+    do: "",
+    add: "ad",
+    sub: "sb",
+    mul: "ml",
+    div: "dv",
+    eq: "eq",
+    neq: "nq",
+    lt: "lt",
+    lte: "le",
+    gt: "gt",
+    gte: "ge",
+    and: "an",
+    or: "or",
+    xor: "xr",
+    not: "nt",
+    boolean: "bt",
+    number: "nm",
+    string: "st",
+    array: "ar",
+    object: "ob",
+    mod: "md",
+    neg: "ng",
+    range: "rn",
+    size: "sz"
   };
 });
 
@@ -3310,6 +3704,7 @@ __export(exports_rex_repl, {
   isIncomplete: () => isIncomplete,
   highlightRexc: () => highlightRexc,
   highlightLine: () => highlightLine,
+  highlightJSON: () => highlightJSON,
   formatVarState: () => formatVarState
 });
 import * as readline from "node:readline";
@@ -3421,6 +3816,7 @@ function highlightRexc(text) {
         break;
       }
       case "=":
+      case "/":
       case "~":
         out += C.red + prefix + tag + C.reset;
         i++;
@@ -3460,6 +3856,32 @@ function highlightRexc(text) {
   }
   return out;
 }
+function highlightJSON(json) {
+  let result = "";
+  let lastIndex = 0;
+  JSON_TOKEN_RE.lastIndex = 0;
+  for (const m of json.matchAll(JSON_TOKEN_RE)) {
+    result += json.slice(lastIndex, m.index);
+    const text = m[0];
+    const g = m.groups;
+    if (g.key) {
+      result += C.cyan + g.key + C.reset + ":";
+    } else if (g.string) {
+      result += C.green + text + C.reset;
+    } else if (g.number) {
+      result += C.yellow + text + C.reset;
+    } else if (g.bool) {
+      result += C.yellow + text + C.reset;
+    } else if (g.null) {
+      result += C.dim + text + C.reset;
+    } else {
+      result += text;
+    }
+    lastIndex = m.index + text.length;
+  }
+  result += json.slice(lastIndex);
+  return result;
+}
 function stripStringsAndComments(source) {
   return source.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g, (m) => " ".repeat(m.length));
 }
@@ -3497,7 +3919,7 @@ function isIncomplete(buffer) {
   const trimmed = buffer.trimEnd();
   if (/[+\-*/%&|^=<>]$/.test(trimmed))
     return true;
-  if (/\b(?:and|or|do|in|of)\s*$/.test(trimmed))
+  if (/\b(?:and|or|nor|do|in|of)\s*$/.test(trimmed))
     return true;
   return false;
 }
@@ -3707,7 +4129,7 @@ async function startRepl() {
       const ir = parseToIR(source);
       const lowered = state.optimize ? optimizeIR(ir) : ir;
       if (state.showIR) {
-        console.log(`${C.dim}  IR: ${JSON.stringify(lowered)}${C.reset}`);
+        console.log(`${C.dim}  IR:${C.reset} ${highlightJSON(JSON.stringify(lowered))}`);
       }
       const rexc = compile(source, { optimize: state.optimize });
       if (state.showRexc) {
@@ -3739,7 +4161,7 @@ async function startRepl() {
   });
   rl.prompt();
 }
-var req, version, C, TOKEN_RE, REXC_DIGITS, KEYWORDS, GAS_LIMIT = 1e7;
+var req, version, C, TOKEN_RE, REXC_DIGITS, JSON_TOKEN_RE, KEYWORDS, GAS_LIMIT = 1e7;
 var init_rex_repl = __esm(() => {
   init_rex();
   init_rexc_interpreter();
@@ -3757,8 +4179,9 @@ var init_rex_repl = __esm(() => {
     gray: "\x1B[90m",
     boldBlue: "\x1B[1;34m"
   };
-  TOKEN_RE = /(?<blockComment>\/\*[\s\S]*?(?:\*\/|$))|(?<lineComment>\/\/[^\n]*)|(?<dstring>"(?:[^"\\]|\\.)*"?)|(?<sstring>'(?:[^'\\]|\\.)*'?)|(?<keyword>\b(?:when|unless|while|for|do|end|in|of|and|or|else|break|continue|delete|self)(?![a-zA-Z0-9_-]))|(?<literal>\b(?:true|false|null|undefined)(?![a-zA-Z0-9_-]))|(?<typePred>\b(?:string|number|object|array|boolean)(?![a-zA-Z0-9_-]))|(?<num>\b(?:0x[0-9a-fA-F]+|0b[01]+|(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\b)/g;
+  TOKEN_RE = /(?<blockComment>\/\*[\s\S]*?(?:\*\/|$))|(?<lineComment>\/\/[^\n]*)|(?<dstring>"(?:[^"\\]|\\.)*"?)|(?<sstring>'(?:[^'\\]|\\.)*'?)|(?<keyword>\b(?:when|unless|while|for|do|end|in|of|and|or|nor|else|break|continue|delete|self)(?![a-zA-Z0-9_-]))|(?<literal>\b(?:true|false|null|undefined|nan)(?![a-zA-Z0-9_-])|-?\binf\b)|(?<typePred>\b(?:string|number|object|array|boolean)(?![a-zA-Z0-9_-]))|(?<num>\b(?:0x[0-9a-fA-F]+|0b[01]+|(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\b)/g;
   REXC_DIGITS = new Set("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_");
+  JSON_TOKEN_RE = /(?<key>"(?:[^"\\]|\\.)*")\s*:|(?<string>"(?:[^"\\]|\\.)*")|(?<number>-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)\b|(?<bool>true|false)|(?<null>null)|(?<brace>[{}[\]])|(?<punct>[:,])/g;
   KEYWORDS = [
     "when",
     "unless",
@@ -3770,6 +4193,7 @@ var init_rex_repl = __esm(() => {
     "of",
     "and",
     "or",
+    "nor",
     "else",
     "break",
     "continue",
@@ -3779,6 +4203,8 @@ var init_rex_repl = __esm(() => {
     "false",
     "null",
     "undefined",
+    "nan",
+    "inf",
     "string",
     "number",
     "object",
@@ -3794,6 +4220,7 @@ import { dirname, resolve } from "node:path";
 import { readFile, writeFile } from "node:fs/promises";
 function parseArgs(argv) {
   const options = {
+    sources: [],
     compile: false,
     ir: false,
     minifyNames: false,
@@ -3839,7 +4266,7 @@ function parseArgs(argv) {
       const value = argv[index + 1];
       if (!value)
         throw new Error("Missing value for --expr");
-      options.expr = value;
+      options.sources.push({ type: "expr", value });
       index += 1;
       continue;
     }
@@ -3847,7 +4274,7 @@ function parseArgs(argv) {
       const value = argv[index + 1];
       if (!value)
         throw new Error("Missing value for --file");
-      options.file = value;
+      options.sources.push({ type: "file", path: value });
       index += 1;
       continue;
     }
@@ -3860,9 +4287,7 @@ function parseArgs(argv) {
       continue;
     }
     if (!arg.startsWith("-")) {
-      if (options.file)
-        throw new Error("Multiple file arguments provided");
-      options.file = arg;
+      options.sources.push({ type: "file", path: arg });
       continue;
     }
     throw new Error(`Unknown option: ${arg}`);
@@ -3880,11 +4305,18 @@ function usage() {
     "  cat input.rex | rex            Evaluate from stdin",
     "  rex -c input.rex               Compile to rexc bytecode",
     "",
+    "  Sources are concatenated in order, so flags and files can be mixed:",
+    "  rex -e 'max = 200' primes.rex  Set max before running script",
+    "  rex primes.rex -e '42'         Run script, then evaluate 42",
+    "",
     "Input:",
     "  <file>                Evaluate/compile a Rex source file",
     "  -e, --expr <source>   Evaluate/compile an inline expression",
     "  -f, --file <path>     Evaluate/compile source from a file",
     "",
+    "  Multiple -e and -f flags (and positional files) can be combined.",
+    "  They are concatenated in the order they appear on the command line.",
+    "",
     "Output mode:",
     "  (default)             Evaluate and output result as JSON",
     "  -c, --compile         Compile to rexc bytecode",
@@ -3909,12 +4341,17 @@ async function readStdin() {
   return Buffer.concat(chunks).toString("utf8");
 }
 async function resolveSource(options) {
-  if (options.expr && options.file)
-    throw new Error("Use only one of --expr, --file, or a positional file path");
-  if (options.expr)
-    return options.expr;
-  if (options.file)
-    return readFile(options.file, "utf8");
+  if (options.sources.length > 0) {
+    const parts = [];
+    for (const seg of options.sources) {
+      if (seg.type === "expr")
+        parts.push(seg.value);
+      else
+        parts.push(await readFile(seg.path, "utf8"));
+    }
+    return parts.join(`
+`);
+  }
   if (!process.stdin.isTTY) {
     const piped = await readStdin();
     if (piped.trim().length > 0)
@@ -3922,6 +4359,13 @@ async function resolveSource(options) {
   }
   throw new Error("No input provided. Use a file path, --expr, or pipe source via stdin.");
 }
+function findFirstFilePath(sources) {
+  for (const seg of sources) {
+    if (seg.type === "file")
+      return seg.path;
+  }
+  return;
+}
 async function loadDomainConfigFromFolder(folderPath) {
   const configPath = resolve(folderPath, ".config.rex");
   try {
@@ -3933,7 +4377,8 @@ async function loadDomainConfigFromFolder(folderPath) {
   }
 }
 async function resolveDomainConfig(options) {
-  const baseFolder = options.file ? dirname(resolve(options.file)) : process.cwd();
+  const filePath = findFirstFilePath(options.sources);
+  const baseFolder = filePath ? dirname(resolve(filePath)) : process.cwd();
   return loadDomainConfigFromFolder(baseFolder);
 }
 async function main() {
@@ -3942,7 +4387,7 @@ async function main() {
     console.log(usage());
     return;
   }
-  const hasSource = options.expr || options.file || !process.stdin.isTTY;
+  const hasSource = options.sources.length > 0 || !process.stdin.isTTY;
   if (!hasSource && !options.compile && !options.ir) {
     const { startRepl: startRepl2 } = await Promise.resolve().then(() => (init_rex_repl(), exports_rex_repl));
     await startRepl2();
@@ -3962,7 +4407,7 @@ async function main() {
     });
   } else {
     const { value } = evaluateSource(source);
-    output = JSON.stringify(value, null, 2);
+    output = stringify(value);
   }
   if (options.out) {
     await writeFile(options.out, `${output}