@creationix/rex 0.3.1 → 0.6.0

package/rex-cli.js

@@ -115,11 +115,11 @@ function encodeDecimal(significand, power) {
 function encodeNumberNode(node) {
   const numberValue = node.value;
   if (Number.isNaN(numberValue))
-    return "5'";
+    return "nan'";
   if (numberValue === Infinity)
-    return "6'";
+    return "inf'";
   if (numberValue === -Infinity)
-    return "7'";
+    return "nif'";
   if (Number.isInteger(numberValue)) {
     const { base, exp } = splitDecimal(numberValue);
     if (exp >= 0 && exp <= 4)
@@ -151,7 +151,7 @@ function encodeNumberNode(node) {
   return encodeDecimal(significand, power);
 }
 function encodeOpcode(opcode) {
-  return `${encodeUint(OPCODE_IDS[opcode])}%`;
+  return `${OPCODE_IDS[opcode]}%`;
 }
 function encodeCallParts(parts) {
   return `(${parts.join("")})`;
@@ -168,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);
@@ -179,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))]);
@@ -196,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")
@@ -207,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));
@@ -240,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})`;
   }
@@ -253,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) {
@@ -285,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":
@@ -298,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":
@@ -313,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":
@@ -328,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") {
@@ -346,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];
@@ -362,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);
@@ -371,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":
@@ -390,11 +441,30 @@ function collectLogicalChain(node, op) {
     return [node];
   return [...collectLogicalChain(node.left, op), ...collectLogicalChain(node.right, op)];
 }
+function formatParseError(source, match) {
+  const message = match.message ?? "Parse failed";
+  const pos = match.getRightmostFailurePosition?.();
+  if (typeof pos !== "number" || !Number.isFinite(pos))
+    return message;
+  const safePos = Math.max(0, Math.min(source.length, pos));
+  const lineStart = source.lastIndexOf(`
+`, safePos - 1) + 1;
+  const lineEndIndex = source.indexOf(`
+`, safePos);
+  const lineEnd = lineEndIndex === -1 ? source.length : lineEndIndex;
+  const lineText = source.slice(lineStart, lineEnd);
+  const lineNumber = source.slice(0, lineStart).split(`
+`).length;
+  const columnNumber = safePos - lineStart + 1;
+  const caret = `${" ".repeat(Math.max(0, columnNumber - 1))}^`;
+  return `${message}
+  ${lineText}
+  ${caret}`;
+}
 function parseToIR(source) {
   const match = grammar.match(source);
   if (!match.succeeded()) {
-    const failure = match;
-    throw new Error(failure.message ?? "Parse failed");
+    throw new Error(formatParseError(source, match));
   }
   return semantics(match).toIR();
 }
@@ -546,78 +616,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);
     }
   }
@@ -761,20 +808,11 @@ function gatherEncodedValueSpans(text) {
   }
   return spans;
 }
-function buildPointerToken(pointerStart, targetStart) {
-  let offset = targetStart - (pointerStart + 1);
+function buildPointerToken(pointerStart, targetStart, occurrenceSize) {
+  const offset = targetStart - pointerStart - occurrenceSize;
   if (offset < 0)
     return;
-  for (let guard = 0;guard < 8; guard += 1) {
-    const prefix = encodeUint(offset);
-    const recalculated = targetStart - (pointerStart + prefix.length + 1);
-    if (recalculated === offset)
-      return `${prefix}^`;
-    offset = recalculated;
-    if (offset < 0)
-      return;
-  }
-  return;
+  return `${encodeUint(offset)}^`;
 }
 function buildDedupeCandidateTable(encoded, minBytes) {
   const spans = gatherEncodedValueSpans(encoded);
@@ -810,854 +848,43 @@ function dedupeLargeEncodedValues(encoded, minBytes = 4) {
         continue;
       const canonical = occurrences[occurrences.length - 1];
       for (let index = occurrences.length - 2;index >= 0; index -= 1) {
-        const occurrence = occurrences[index];
-        if (occurrence.span.end > canonical.span.start)
-          continue;
-        if (current.slice(occurrence.span.start, occurrence.span.end) !== value)
-          continue;
-        const canonicalCurrentStart = current.length - canonical.offsetFromEnd - canonical.sizeBytes;
-        const pointerToken = buildPointerToken(occurrence.span.start, canonicalCurrentStart);
-        if (!pointerToken)
-          continue;
-        if (pointerToken.length >= occurrence.sizeBytes)
-          continue;
-        current = `${current.slice(0, occurrence.span.start)}${pointerToken}${current.slice(occurrence.span.end)}`;
-        replaced = true;
-        break;
-      }
-      if (replaced)
-        break;
-    }
-    if (!replaced)
-      return current;
-  }
-}
-function encodeIR(node, options) {
-  const previous = activeEncodeOptions;
-  activeEncodeOptions = options;
-  try {
-    const encoded = encodeNode(node);
-    if (options?.dedupeValues) {
-      return dedupeLargeEncodedValues(encoded, options.dedupeMinBytes ?? 4);
-    }
-    return encoded;
-  } finally {
-    activeEncodeOptions = previous;
-  }
-}
-function cloneNode(node) {
-  return structuredClone(node);
-}
-function emptyOptimizeEnv() {
-  return { constants: {}, selfCaptures: {} };
-}
-function cloneOptimizeEnv(env) {
-  return {
-    constants: { ...env.constants },
-    selfCaptures: { ...env.selfCaptures }
-  };
-}
-function clearOptimizeEnv(env) {
-  for (const key of Object.keys(env.constants))
-    delete env.constants[key];
-  for (const key of Object.keys(env.selfCaptures))
-    delete env.selfCaptures[key];
-}
-function clearBinding(env, name) {
-  delete env.constants[name];
-  delete env.selfCaptures[name];
-}
-function selfTargetFromNode(node, currentDepth) {
-  if (node.type === "self")
-    return currentDepth;
-  if (node.type === "selfDepth") {
-    const target = currentDepth - (node.depth - 1);
-    if (target >= 1)
-      return target;
-  }
-  return;
-}
-function selfNodeFromTarget(targetDepth, currentDepth) {
-  const relDepth = currentDepth - targetDepth + 1;
-  if (!Number.isInteger(relDepth) || relDepth < 1)
-    return;
-  if (relDepth === 1)
-    return { type: "self" };
-  return { type: "selfDepth", depth: relDepth };
-}
-function dropBindingNames(env, binding) {
-  if (binding.type === "binding:valueIn") {
-    clearBinding(env, binding.value);
-    return;
-  }
-  if (binding.type === "binding:keyValueIn") {
-    clearBinding(env, binding.key);
-    clearBinding(env, binding.value);
-    return;
-  }
-  if (binding.type === "binding:keyOf") {
-    clearBinding(env, binding.key);
-  }
-}
-function collectReads(node, out) {
-  switch (node.type) {
-    case "identifier":
-      out.add(node.name);
-      return;
-    case "group":
-      collectReads(node.expression, out);
-      return;
-    case "array":
-      for (const item of node.items)
-        collectReads(item, out);
-      return;
-    case "object":
-      for (const entry of node.entries) {
-        collectReads(entry.key, out);
-        collectReads(entry.value, out);
-      }
-      return;
-    case "arrayComprehension":
-      collectReads(node.binding.source, out);
-      collectReads(node.body, out);
-      return;
-    case "objectComprehension":
-      collectReads(node.binding.source, out);
-      collectReads(node.key, out);
-      collectReads(node.value, out);
-      return;
-    case "unary":
-      collectReads(node.value, out);
-      return;
-    case "binary":
-      collectReads(node.left, out);
-      collectReads(node.right, out);
-      return;
-    case "assign":
-      if (!(node.op === "=" && node.place.type === "identifier"))
-        collectReads(node.place, out);
-      collectReads(node.value, out);
-      return;
-    case "navigation":
-      collectReads(node.target, out);
-      for (const segment of node.segments) {
-        if (segment.type === "dynamic")
-          collectReads(segment.key, out);
-      }
-      return;
-    case "call":
-      collectReads(node.callee, out);
-      for (const arg of node.args)
-        collectReads(arg, out);
-      return;
-    case "conditional":
-      collectReads(node.condition, out);
-      for (const part of node.thenBlock)
-        collectReads(part, out);
-      if (node.elseBranch)
-        collectReadsElse(node.elseBranch, out);
-      return;
-    case "for":
-      collectReads(node.binding.source, out);
-      for (const part of node.body)
-        collectReads(part, out);
-      return;
-    case "program":
-      for (const part of node.body)
-        collectReads(part, out);
-      return;
-    default:
-      return;
-  }
-}
-function collectReadsElse(elseBranch, out) {
-  if (elseBranch.type === "else") {
-    for (const part of elseBranch.block)
-      collectReads(part, out);
-    return;
-  }
-  collectReads(elseBranch.condition, out);
-  for (const part of elseBranch.thenBlock)
-    collectReads(part, out);
-  if (elseBranch.elseBranch)
-    collectReadsElse(elseBranch.elseBranch, out);
-}
-function isPureNode(node) {
-  switch (node.type) {
-    case "identifier":
-    case "self":
-    case "selfDepth":
-    case "boolean":
-    case "null":
-    case "undefined":
-    case "number":
-    case "string":
-    case "key":
-      return true;
-    case "group":
-      return isPureNode(node.expression);
-    case "array":
-      return node.items.every((item) => isPureNode(item));
-    case "object":
-      return node.entries.every((entry) => isPureNode(entry.key) && isPureNode(entry.value));
-    case "navigation":
-      return isPureNode(node.target) && node.segments.every((segment) => segment.type === "static" || isPureNode(segment.key));
-    case "unary":
-      return node.op !== "delete" && isPureNode(node.value);
-    case "binary":
-      return isPureNode(node.left) && isPureNode(node.right);
-    default:
-      return false;
-  }
-}
-function eliminateDeadAssignments(block) {
-  const needed = new Set;
-  const out = [];
-  for (let index = block.length - 1;index >= 0; index -= 1) {
-    const node = block[index];
-    if (node.type === "conditional") {
-      let rewritten = node;
-      if (node.condition.type === "assign" && node.condition.op === "=" && node.condition.place.type === "identifier") {
-        const name = node.condition.place.name;
-        const branchReads = new Set;
-        for (const part of node.thenBlock)
-          collectReads(part, branchReads);
-        if (node.elseBranch)
-          collectReadsElse(node.elseBranch, branchReads);
-        if (!needed.has(name) && !branchReads.has(name)) {
-          rewritten = {
-            type: "conditional",
-            head: node.head,
-            condition: node.condition.value,
-            thenBlock: node.thenBlock,
-            elseBranch: node.elseBranch
-          };
-        }
-      }
-      collectReads(rewritten, needed);
-      out.push(rewritten);
-      continue;
-    }
-    if (node.type === "assign" && node.op === "=" && node.place.type === "identifier") {
-      collectReads(node.value, needed);
-      const name = node.place.name;
-      const canDrop = !needed.has(name) && isPureNode(node.value);
-      needed.delete(name);
-      if (canDrop)
-        continue;
-      out.push(node);
-      continue;
-    }
-    collectReads(node, needed);
-    out.push(node);
-  }
-  out.reverse();
-  return out;
-}
-function hasIdentifierRead(node, name, asPlace = false) {
-  if (node.type === "identifier")
-    return !asPlace && node.name === name;
-  switch (node.type) {
-    case "group":
-      return hasIdentifierRead(node.expression, name);
-    case "array":
-      return node.items.some((item) => hasIdentifierRead(item, name));
-    case "object":
-      return node.entries.some((entry) => hasIdentifierRead(entry.key, name) || hasIdentifierRead(entry.value, name));
-    case "navigation":
-      return hasIdentifierRead(node.target, name) || node.segments.some((segment) => segment.type === "dynamic" && hasIdentifierRead(segment.key, name));
-    case "unary":
-      return hasIdentifierRead(node.value, name, node.op === "delete");
-    case "binary":
-      return hasIdentifierRead(node.left, name) || hasIdentifierRead(node.right, name);
-    case "assign":
-      return hasIdentifierRead(node.place, name, true) || hasIdentifierRead(node.value, name);
-    default:
-      return false;
-  }
-}
-function countIdentifierReads(node, name, asPlace = false) {
-  if (node.type === "identifier")
-    return !asPlace && node.name === name ? 1 : 0;
-  switch (node.type) {
-    case "group":
-      return countIdentifierReads(node.expression, name);
-    case "array":
-      return node.items.reduce((sum, item) => sum + countIdentifierReads(item, name), 0);
-    case "object":
-      return node.entries.reduce((sum, entry) => sum + countIdentifierReads(entry.key, name) + countIdentifierReads(entry.value, name), 0);
-    case "navigation":
-      return countIdentifierReads(node.target, name) + node.segments.reduce((sum, segment) => sum + (segment.type === "dynamic" ? countIdentifierReads(segment.key, name) : 0), 0);
-    case "unary":
-      return countIdentifierReads(node.value, name, node.op === "delete");
-    case "binary":
-      return countIdentifierReads(node.left, name) + countIdentifierReads(node.right, name);
-    case "assign":
-      return countIdentifierReads(node.place, name, true) + countIdentifierReads(node.value, name);
-    default:
-      return 0;
-  }
-}
-function replaceIdentifier(node, name, replacement, asPlace = false) {
-  if (node.type === "identifier") {
-    if (!asPlace && node.name === name)
-      return cloneNode(replacement);
-    return node;
-  }
-  switch (node.type) {
-    case "group":
-      return {
-        type: "group",
-        expression: replaceIdentifier(node.expression, name, replacement)
-      };
-    case "array":
-      return { type: "array", items: node.items.map((item) => replaceIdentifier(item, name, replacement)) };
-    case "object":
-      return {
-        type: "object",
-        entries: node.entries.map((entry) => ({
-          key: replaceIdentifier(entry.key, name, replacement),
-          value: replaceIdentifier(entry.value, name, replacement)
-        }))
-      };
-    case "navigation":
-      return {
-        type: "navigation",
-        target: replaceIdentifier(node.target, name, replacement),
-        segments: node.segments.map((segment) => segment.type === "static" ? segment : { type: "dynamic", key: replaceIdentifier(segment.key, name, replacement) })
-      };
-    case "unary":
-      return {
-        type: "unary",
-        op: node.op,
-        value: replaceIdentifier(node.value, name, replacement, node.op === "delete")
-      };
-    case "binary":
-      return {
-        type: "binary",
-        op: node.op,
-        left: replaceIdentifier(node.left, name, replacement),
-        right: replaceIdentifier(node.right, name, replacement)
-      };
-    case "assign":
-      return {
-        type: "assign",
-        op: node.op,
-        place: replaceIdentifier(node.place, name, replacement, true),
-        value: replaceIdentifier(node.value, name, replacement)
-      };
-    default:
-      return node;
-  }
-}
-function isSafeInlineTargetNode(node) {
-  if (isPureNode(node))
-    return true;
-  if (node.type === "assign" && node.op === "=") {
-    return isPureNode(node.place) && isPureNode(node.value);
-  }
-  return false;
-}
-function inlineAdjacentPureAssignments(block) {
-  const out = [...block];
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (let index = 0;index < out.length - 1; index += 1) {
-      const current = out[index];
-      if (current.type !== "assign" || current.op !== "=" || current.place.type !== "identifier")
-        continue;
-      if (!isPureNode(current.value))
-        continue;
-      const name = current.place.name;
-      if (hasIdentifierRead(current.value, name))
-        continue;
-      const next = out[index + 1];
-      if (!isSafeInlineTargetNode(next))
-        continue;
-      if (countIdentifierReads(next, name) !== 1)
-        continue;
-      out[index + 1] = replaceIdentifier(next, name, current.value);
-      out.splice(index, 1);
-      changed = true;
-      break;
-    }
-  }
-  return out;
-}
-function toNumberNode(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) };
-}
-function toLiteralNode(value) {
-  if (value === undefined)
-    return { type: "undefined" };
-  if (value === null)
-    return { type: "null" };
-  if (typeof value === "boolean")
-    return { type: "boolean", value };
-  if (typeof value === "number")
-    return toNumberNode(value);
-  if (typeof value === "string")
-    return toStringNode(value);
-  if (Array.isArray(value)) {
-    const items = [];
-    for (const item of value) {
-      const lowered = toLiteralNode(item);
-      if (!lowered)
-        return;
-      items.push(lowered);
-    }
-    return { type: "array", items };
-  }
-  if (value && typeof value === "object") {
-    const entries = [];
-    for (const [key, entryValue] of Object.entries(value)) {
-      const loweredValue = toLiteralNode(entryValue);
-      if (!loweredValue)
-        return;
-      entries.push({ key: { type: "key", name: key }, value: loweredValue });
-    }
-    return { type: "object", entries };
-  }
-  return;
-}
-function constValue(node) {
-  switch (node.type) {
-    case "undefined":
-      return;
-    case "null":
-      return null;
-    case "boolean":
-      return node.value;
-    case "number":
-      return node.value;
-    case "string":
-      return decodeStringLiteral(node.raw);
-    case "key":
-      return node.name;
-    case "array": {
-      const out = [];
-      for (const item of node.items) {
-        const value = constValue(item);
-        if (value === undefined && item.type !== "undefined")
-          return;
-        out.push(value);
-      }
-      return out;
-    }
-    case "object": {
-      const out = {};
-      for (const entry of node.entries) {
-        const key = constValue(entry.key);
-        if (key === undefined && entry.key.type !== "undefined")
-          return;
-        const value = constValue(entry.value);
-        if (value === undefined && entry.value.type !== "undefined")
-          return;
-        out[String(key)] = value;
-      }
-      return out;
-    }
-    default:
-      return;
-  }
-}
-function isDefinedValue(value) {
-  return value !== undefined;
-}
-function foldUnary(op, value) {
-  if (op === "neg") {
-    if (typeof value !== "number")
-      return;
-    return -value;
-  }
-  if (op === "not") {
-    if (typeof value === "boolean")
-      return !value;
-    if (typeof value === "number")
-      return ~value;
-    return;
-  }
-  return;
-}
-function foldBinary(op, left, right) {
-  if (op === "add" || op === "sub" || op === "mul" || op === "div" || op === "mod") {
-    if (typeof left !== "number" || typeof right !== "number")
-      return;
-    if (op === "add")
-      return left + right;
-    if (op === "sub")
-      return left - right;
-    if (op === "mul")
-      return left * right;
-    if (op === "div")
-      return left / right;
-    return left % right;
-  }
-  if (op === "bitAnd" || op === "bitOr" || op === "bitXor") {
-    if (typeof left !== "number" || typeof right !== "number")
-      return;
-    if (op === "bitAnd")
-      return left & right;
-    if (op === "bitOr")
-      return left | right;
-    return left ^ right;
-  }
-  if (op === "eq")
-    return left === right ? left : undefined;
-  if (op === "neq")
-    return left !== right ? left : undefined;
-  if (op === "gt" || op === "gte" || op === "lt" || op === "lte") {
-    if (typeof left !== "number" || typeof right !== "number")
-      return;
-    if (op === "gt")
-      return left > right ? left : undefined;
-    if (op === "gte")
-      return left >= right ? left : undefined;
-    if (op === "lt")
-      return left < right ? left : undefined;
-    return left <= right ? left : undefined;
-  }
-  if (op === "and")
-    return isDefinedValue(left) ? right : undefined;
-  if (op === "or")
-    return isDefinedValue(left) ? left : right;
-  return;
-}
-function optimizeElse(elseBranch, env, currentDepth) {
-  if (!elseBranch)
-    return;
-  if (elseBranch.type === "else") {
-    return { type: "else", block: optimizeBlock(elseBranch.block, cloneOptimizeEnv(env), currentDepth) };
-  }
-  const optimizedCondition = optimizeNode(elseBranch.condition, env, currentDepth);
-  const foldedCondition = constValue(optimizedCondition);
-  if (foldedCondition !== undefined || optimizedCondition.type === "undefined") {
-    const passes = elseBranch.head === "when" ? isDefinedValue(foldedCondition) : !isDefinedValue(foldedCondition);
-    if (passes) {
-      return {
-        type: "else",
-        block: optimizeBlock(elseBranch.thenBlock, cloneOptimizeEnv(env), currentDepth)
-      };
-    }
-    return optimizeElse(elseBranch.elseBranch, env, currentDepth);
-  }
-  return {
-    type: "elseChain",
-    head: elseBranch.head,
-    condition: optimizedCondition,
-    thenBlock: optimizeBlock(elseBranch.thenBlock, cloneOptimizeEnv(env), currentDepth),
-    elseBranch: optimizeElse(elseBranch.elseBranch, cloneOptimizeEnv(env), currentDepth)
-  };
-}
-function optimizeBlock(block, env, currentDepth) {
-  const out = [];
-  for (const node of block) {
-    const optimized = optimizeNode(node, env, currentDepth);
-    out.push(optimized);
-    if (optimized.type === "break" || optimized.type === "continue")
-      break;
-    if (optimized.type === "assign" && optimized.op === "=" && optimized.place.type === "identifier") {
-      const selfTarget = selfTargetFromNode(optimized.value, currentDepth);
-      if (selfTarget !== undefined) {
-        env.selfCaptures[optimized.place.name] = selfTarget;
-        delete env.constants[optimized.place.name];
-        continue;
-      }
-      const folded = constValue(optimized.value);
-      if (folded !== undefined || optimized.value.type === "undefined") {
-        env.constants[optimized.place.name] = cloneNode(optimized.value);
-        delete env.selfCaptures[optimized.place.name];
-      } else {
-        clearBinding(env, optimized.place.name);
-      }
-      continue;
-    }
-    if (optimized.type === "unary" && optimized.op === "delete" && optimized.value.type === "identifier") {
-      clearBinding(env, optimized.value.name);
-      continue;
-    }
-    if (optimized.type === "assign" && optimized.place.type === "identifier") {
-      clearBinding(env, optimized.place.name);
-      continue;
-    }
-    if (optimized.type === "assign" || optimized.type === "for" || optimized.type === "call") {
-      clearOptimizeEnv(env);
-    }
-  }
-  return inlineAdjacentPureAssignments(eliminateDeadAssignments(out));
-}
-function optimizeNode(node, env, currentDepth, asPlace = false) {
-  switch (node.type) {
-    case "program": {
-      const body = optimizeBlock(node.body, cloneOptimizeEnv(env), currentDepth);
-      if (body.length === 0)
-        return { type: "undefined" };
-      if (body.length === 1)
-        return body[0];
-      return { type: "program", body };
-    }
-    case "identifier": {
-      if (asPlace)
-        return node;
-      const selfTarget = env.selfCaptures[node.name];
-      if (selfTarget !== undefined) {
-        const rewritten = selfNodeFromTarget(selfTarget, currentDepth);
-        if (rewritten)
-          return rewritten;
-      }
-      const replacement = env.constants[node.name];
-      return replacement ? cloneNode(replacement) : node;
-    }
-    case "group": {
-      return optimizeNode(node.expression, env, currentDepth);
-    }
-    case "array": {
-      return { type: "array", items: node.items.map((item) => optimizeNode(item, env, currentDepth)) };
-    }
-    case "object": {
-      return {
-        type: "object",
-        entries: node.entries.map((entry) => ({
-          key: optimizeNode(entry.key, env, currentDepth),
-          value: optimizeNode(entry.value, env, currentDepth)
-        }))
-      };
-    }
-    case "unary": {
-      const value = optimizeNode(node.value, env, currentDepth, node.op === "delete");
-      const foldedValue = constValue(value);
-      if (foldedValue !== undefined || value.type === "undefined") {
-        const folded = foldUnary(node.op, foldedValue);
-        const literal = folded === undefined ? undefined : toLiteralNode(folded);
-        if (literal)
-          return literal;
-      }
-      return { type: "unary", op: node.op, value };
-    }
-    case "binary": {
-      const left = optimizeNode(node.left, env, currentDepth);
-      const right = optimizeNode(node.right, env, currentDepth);
-      const leftValue = constValue(left);
-      const rightValue = constValue(right);
-      if ((leftValue !== undefined || left.type === "undefined") && (rightValue !== undefined || right.type === "undefined")) {
-        const folded = foldBinary(node.op, leftValue, rightValue);
-        const literal = folded === undefined ? undefined : toLiteralNode(folded);
-        if (literal)
-          return literal;
-      }
-      return { type: "binary", op: node.op, left, right };
-    }
-    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) });
-      const targetValue = constValue(target);
-      if (targetValue !== undefined || target.type === "undefined") {
-        let current = targetValue;
-        let foldable = true;
-        for (const segment of segments) {
-          if (!foldable)
-            break;
-          const key = segment.type === "static" ? segment.key : constValue(segment.key);
-          if (segment.type === "dynamic" && key === undefined && segment.key.type !== "undefined") {
-            foldable = false;
-            break;
-          }
-          if (current === null || current === undefined) {
-            current = undefined;
-            continue;
-          }
-          current = current[String(key)];
-        }
-        if (foldable) {
-          const literal = toLiteralNode(current);
-          if (literal)
-            return literal;
-        }
-      }
-      return {
-        type: "navigation",
-        target,
-        segments
-      };
-    }
-    case "call": {
-      return {
-        type: "call",
-        callee: optimizeNode(node.callee, env, currentDepth),
-        args: node.args.map((arg) => optimizeNode(arg, env, currentDepth))
-      };
-    }
-    case "assign": {
-      return {
-        type: "assign",
-        op: node.op,
-        place: optimizeNode(node.place, env, currentDepth, true),
-        value: optimizeNode(node.value, env, currentDepth)
-      };
-    }
-    case "conditional": {
-      const condition = optimizeNode(node.condition, env, currentDepth);
-      const thenEnv = cloneOptimizeEnv(env);
-      if (condition.type === "assign" && condition.op === "=" && condition.place.type === "identifier") {
-        thenEnv.selfCaptures[condition.place.name] = currentDepth;
-        delete thenEnv.constants[condition.place.name];
-      }
-      const conditionValue = constValue(condition);
-      if (conditionValue !== undefined || condition.type === "undefined") {
-        const passes = node.head === "when" ? isDefinedValue(conditionValue) : !isDefinedValue(conditionValue);
-        if (passes) {
-          const thenBlock2 = optimizeBlock(node.thenBlock, thenEnv, currentDepth);
-          if (thenBlock2.length === 0)
-            return { type: "undefined" };
-          if (thenBlock2.length === 1)
-            return thenBlock2[0];
-          return { type: "program", body: thenBlock2 };
-        }
-        if (!node.elseBranch)
-          return { type: "undefined" };
-        const loweredElse = optimizeElse(node.elseBranch, cloneOptimizeEnv(env), currentDepth);
-        if (!loweredElse)
-          return { type: "undefined" };
-        if (loweredElse.type === "else") {
-          if (loweredElse.block.length === 0)
-            return { type: "undefined" };
-          if (loweredElse.block.length === 1)
-            return loweredElse.block[0];
-          return { type: "program", body: loweredElse.block };
-        }
-        return {
-          type: "conditional",
-          head: loweredElse.head,
-          condition: loweredElse.condition,
-          thenBlock: loweredElse.thenBlock,
-          elseBranch: loweredElse.elseBranch
-        };
-      }
-      const thenBlock = optimizeBlock(node.thenBlock, thenEnv, currentDepth);
-      const elseBranch = optimizeElse(node.elseBranch, cloneOptimizeEnv(env), currentDepth);
-      let finalCondition = condition;
-      if (condition.type === "assign" && condition.op === "=" && condition.place.type === "identifier") {
-        const name = condition.place.name;
-        const reads = new Set;
-        for (const part of thenBlock)
-          collectReads(part, reads);
-        if (elseBranch)
-          collectReadsElse(elseBranch, reads);
-        if (!reads.has(name)) {
-          finalCondition = condition.value;
-        }
+        const occurrence = occurrences[index];
+        if (occurrence.span.end > canonical.span.start)
+          continue;
+        if (current.slice(occurrence.span.start, occurrence.span.end) !== value)
+          continue;
+        const canonicalCurrentStart = current.length - canonical.offsetFromEnd - canonical.sizeBytes;
+        const pointerToken = buildPointerToken(occurrence.span.start, canonicalCurrentStart, occurrence.sizeBytes);
+        if (!pointerToken)
+          continue;
+        if (pointerToken.length >= occurrence.sizeBytes)
+          continue;
+        current = `${current.slice(0, occurrence.span.start)}${pointerToken}${current.slice(occurrence.span.end)}`;
+        replaced = true;
+        break;
       }
-      return {
-        type: "conditional",
-        head: node.head,
-        condition: finalCondition,
-        thenBlock,
-        elseBranch
-      };
-    }
-    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 bodyEnv = cloneOptimizeEnv(env);
-      dropBindingNames(bodyEnv, binding);
-      return {
-        type: "for",
-        binding,
-        body: optimizeBlock(node.body, bodyEnv, currentDepth + 1)
-      };
-    }
-    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 bodyEnv = cloneOptimizeEnv(env);
-      dropBindingNames(bodyEnv, binding);
-      return {
-        type: "arrayComprehension",
-        binding,
-        body: optimizeNode(node.body, bodyEnv, currentDepth + 1)
-      };
+      if (replaced)
+        break;
     }
-    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 bodyEnv = cloneOptimizeEnv(env);
-      dropBindingNames(bodyEnv, binding);
-      return {
-        type: "objectComprehension",
-        binding,
-        key: optimizeNode(node.key, bodyEnv, currentDepth + 1),
-        value: optimizeNode(node.value, bodyEnv, currentDepth + 1)
-      };
+    if (!replaced)
+      return current;
+  }
+}
+function encodeIR(node, options) {
+  const previous = activeEncodeOptions;
+  activeEncodeOptions = options;
+  try {
+    const encoded = encodeNode(node);
+    if (options?.dedupeValues) {
+      return dedupeLargeEncodedValues(encoded, options.dedupeMinBytes ?? 4);
     }
-    default:
-      return node;
+    return encoded;
+  } finally {
+    activeEncodeOptions = previous;
   }
 }
 function optimizeIR(node) {
-  return optimizeNode(node, emptyOptimizeEnv(), 1);
+  return node;
 }
 function collectLocalBindings(node, locals) {
   switch (node.type) {
@@ -1703,6 +930,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)
@@ -1719,11 +950,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;
   }
@@ -1815,6 +1055,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)
@@ -1831,11 +1075,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;
   }
@@ -1910,6 +1163,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 {
@@ -1939,6 +1198,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",
@@ -1946,34 +1211,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) };
-  }
-  if (binding.type === "binding:valueIn") {
-    return {
-      type: "binding:valueIn",
-      value: map.get(binding.value) ?? binding.value,
-      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: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") {
@@ -2020,9 +1282,9 @@ 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
   });
@@ -2105,7 +1367,7 @@ function buildPostfix(base, steps) {
   flushSegments();
   return current;
 }
-var require2, rexGrammarModule, rexGrammar, grammar, semantics, DIGITS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_", OPCODE_IDS, FIRST_NON_RESERVED_REF = 8, DOMAIN_DIGIT_INDEX, BINARY_TO_OPCODE, ASSIGN_COMPOUND_TO_OPCODE, DEC_PARTS, 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");
@@ -2113,30 +1375,31 @@ 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"
   };
-  DOMAIN_DIGIT_INDEX = new Map(Array.from(DIGITS).map((char, index) => [char, index]));
+  KEYWORD_OPCODES = new Set(["boolean", "number", "string", "array", "object"]);
   BINARY_TO_OPCODE = {
     add: "add",
     sub: "sub",
@@ -2211,6 +1474,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() };
     },
@@ -2220,6 +1486,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",
@@ -2260,6 +1529,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() };
     },
@@ -2313,14 +1585,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",
@@ -2335,30 +1599,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(),
@@ -2366,6 +1644,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",
@@ -2394,6 +1696,40 @@ 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()
+      };
+    },
+    IterBindingComprehension_keyValueIn(key, _comma, value, _in, source) {
+      return {
+        type: "binding:keyValueIn",
+        key: key.sourceString,
+        value: value.sourceString,
+        source: source.toIR()
+      };
+    },
+    IterBindingComprehension_valueIn(value, _in, source) {
+      return {
+        type: "binding:valueIn",
+        value: value.sourceString,
+        source: source.toIR()
+      };
+    },
+    IterBindingComprehension_keyOf(key, _of, source) {
+      return {
+        type: "binding:keyOf",
+        key: key.sourceString,
+        source: source.toIR()
+      };
+    },
     Pair(key, _colon, value) {
       return { key: key.toIR(), value: value.toIR() };
     },
@@ -2495,7 +1831,6 @@ class CursorInterpreter {
   pos = 0;
   state;
   selfStack;
-  opcodeMarkers;
   pointerCache = new Map;
   gasLimit;
   gas = 0;
@@ -2510,28 +1845,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,
-        5: ctx.refs?.[5] ?? NaN,
-        6: ctx.refs?.[6] ?? Infinity,
-        7: ctx.refs?.[7] ?? -Infinity
+        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);
       }
     }
   }
@@ -2592,6 +1921,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}`);
@@ -2632,36 +1977,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;
@@ -2678,6 +2021,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();
@@ -2705,7 +2056,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}`);
     }
@@ -2727,7 +2078,9 @@ class CursorInterpreter {
     }
     this.ensure(")");
     if (typeof callee === "object" && callee && "__opcode" in callee) {
-      return this.applyOpcode(callee.__opcode, args);
+      const marker = callee;
+      const opArgs = marker.__receiver !== undefined ? [marker.__receiver, ...args] : args;
+      return this.applyOpcode(marker.__opcode, opArgs);
     }
     return this.navigate(callee, args);
   }
@@ -2918,15 +2271,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 [];
   }
@@ -2971,21 +2320,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)) {
@@ -3006,6 +2366,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 = [];
@@ -3076,10 +2488,19 @@ class CursorInterpreter {
       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]);
+        if (Array.isArray(args[0]) && Array.isArray(args[1])) {
+          return [...args[0], ...args[1]];
+        }
+        if (args[0] && args[1] && typeof args[0] === "object" && typeof args[1] === "object" && !Array.isArray(args[0]) && !Array.isArray(args[1])) {
+          return { ...args[0], ...args[1] };
         }
-        return Number(args[0]) + Number(args[1]);
+        if (typeof args[0] === "string" && typeof args[1] === "string") {
+          return args[0] + args[1];
+        }
+        if (typeof args[0] === "number" && typeof args[1] === "number") {
+          return args[0] + args[1];
+        }
+        return;
       case OPCODES.sub:
         if (args[0] === undefined || args[1] === undefined)
           return;
@@ -3148,6 +2569,98 @@ 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 "array:push": {
+        const target = args[0];
+        if (!Array.isArray(target))
+          return;
+        const next = target.slice();
+        for (let i = 1;i < args.length; i += 1)
+          next.push(args[i]);
+        return next;
+      }
+      case "array:pop": {
+        const target = args[0];
+        if (!Array.isArray(target) || target.length === 0)
+          return;
+        return target[target.length - 1];
+      }
+      case "array:unshift": {
+        const target = args[0];
+        if (!Array.isArray(target))
+          return;
+        const next = target.slice();
+        for (let i = args.length - 1;i >= 1; i -= 1)
+          next.unshift(args[i]);
+        return next;
+      }
+      case "array:shift": {
+        const target = args[0];
+        if (!Array.isArray(target) || target.length === 0)
+          return;
+        return target[0];
+      }
+      case "array:slice": {
+        const target = args[0];
+        if (!Array.isArray(target))
+          return;
+        const start = args.length > 1 && args[1] !== undefined ? Number(args[1]) : undefined;
+        const end = args.length > 2 && args[2] !== undefined ? Number(args[2]) : undefined;
+        return target.slice(start, end);
+      }
+      case "array:join": {
+        const target = args[0];
+        if (!Array.isArray(target))
+          return;
+        const sep = args.length > 1 && args[1] !== undefined ? String(args[1]) : ",";
+        return target.map((item) => String(item)).join(sep);
+      }
+      case "string:split": {
+        const target = args[0];
+        if (typeof target !== "string")
+          return;
+        if (args.length < 2 || args[1] === undefined)
+          return [target];
+        return target.split(String(args[1]));
+      }
+      case "string:join": {
+        const target = args[0];
+        if (typeof target !== "string")
+          return;
+        const parts = Array.from(target);
+        const sep = args.length > 1 && args[1] !== undefined ? String(args[1]) : "";
+        return parts.join(sep);
+      }
+      case "string:slice": {
+        const target = args[0];
+        if (typeof target !== "string")
+          return;
+        const start = args.length > 1 && args[1] !== undefined ? Number(args[1]) : undefined;
+        const end = args.length > 2 && args[2] !== undefined ? Number(args[2]) : undefined;
+        return Array.from(target).slice(start, end).join("");
+      }
+      case "string:starts-with": {
+        const target = args[0];
+        if (typeof target !== "string")
+          return;
+        const prefix = args.length > 1 && args[1] !== undefined ? String(args[1]) : "";
+        return target.startsWith(prefix);
+      }
+      case "string:ends-with": {
+        const target = args[0];
+        if (typeof target !== "string")
+          return;
+        const suffix = args.length > 1 && args[1] !== undefined ? String(args[1]) : "";
+        return target.endsWith(suffix);
+      }
       default:
         throw new Error(`Unknown opcode ${id}`);
     }
@@ -3157,10 +2670,103 @@ 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) {
+    if (typeof key === "string" && key === "size") {
+      if (Array.isArray(target))
+        return target.length;
+      if (typeof target === "string")
+        return Array.from(target).length;
+    }
+    const index = this.parseIndexKey(key);
+    if (Array.isArray(target)) {
+      if (index !== undefined)
+        return target[index];
+      if (typeof key === "string")
+        return this.resolveArrayMethod(target, key);
+      return;
+    }
+    if (typeof target === "string") {
+      if (index !== undefined)
+        return Array.from(target)[index];
+      if (typeof key === "string")
+        return this.resolveStringMethod(target, key);
+      return;
+    }
+    if (this.isPlainObject(target)) {
+      const prop = String(key);
+      if (!Object.prototype.hasOwnProperty.call(target, prop))
+        return;
+      return target[prop];
+    }
+    return;
+  }
+  resolveArrayMethod(target, key) {
+    switch (key) {
+      case "push":
+        return { __opcode: "array:push", __receiver: target };
+      case "pop":
+        return { __opcode: "array:pop", __receiver: target };
+      case "unshift":
+        return { __opcode: "array:unshift", __receiver: target };
+      case "shift":
+        return { __opcode: "array:shift", __receiver: target };
+      case "slice":
+        return { __opcode: "array:slice", __receiver: target };
+      case "join":
+        return { __opcode: "array:join", __receiver: target };
+      default:
+        return;
+    }
+  }
+  resolveStringMethod(target, key) {
+    switch (key) {
+      case "split":
+        return { __opcode: "string:split", __receiver: target };
+      case "join":
+        return { __opcode: "string:join", __receiver: target };
+      case "slice":
+        return { __opcode: "string:slice", __receiver: target };
+      case "starts-with":
+        return { __opcode: "string:starts-with", __receiver: target };
+      case "ends-with":
+        return { __opcode: "string:ends-with", __receiver: target };
+      default:
+        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();
@@ -3215,13 +2821,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;
@@ -3232,17 +2838,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];
+    }
+    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;
     }
-    target[String(place.keys[place.keys.length - 1])] = value;
+    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;
@@ -3251,11 +2888,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);
@@ -3271,12 +2926,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();
@@ -3311,7 +2966,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;
@@ -3347,28 +3003,29 @@ 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"
   };
 });
 
@@ -3376,14 +3033,73 @@ var init_rexc_interpreter = __esm(() => {
 var exports_rex_repl = {};
 __export(exports_rex_repl, {
   startRepl: () => startRepl,
+  setColorEnabled: () => setColorEnabled,
   isIncomplete: () => isIncomplete,
   highlightRexc: () => highlightRexc,
   highlightLine: () => highlightLine,
   highlightJSON: () => highlightJSON,
+  highlightAuto: () => highlightAuto,
   formatVarState: () => formatVarState
 });
 import * as readline from "node:readline";
 import { createRequire as createRequire2 } from "node:module";
+import { readdirSync, statSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve, dirname, basename } from "node:path";
+import { homedir } from "node:os";
+function createColors(enabled) {
+  if (!enabled) {
+    return {
+      reset: "",
+      bold: "",
+      dim: "",
+      red: "",
+      green: "",
+      yellow: "",
+      blue: "",
+      magenta: "",
+      cyan: "",
+      gray: "",
+      keyword: ""
+    };
+  }
+  return {
+    reset: "\x1B[0m",
+    bold: "\x1B[1m",
+    dim: "\x1B[2m",
+    red: "\x1B[38;5;203m",
+    green: "\x1B[38;5;114m",
+    yellow: "\x1B[38;5;179m",
+    blue: "\x1B[38;5;75m",
+    magenta: "\x1B[38;5;141m",
+    cyan: "\x1B[38;5;81m",
+    gray: "\x1B[38;5;245m",
+    keyword: "\x1B[1;38;5;208m"
+  };
+}
+function setColorEnabled(enabled) {
+  colorEnabled = enabled;
+  C = createColors(enabled);
+}
+function formatJson(value, indent = 2) {
+  const normalized = normalizeJsonValue(value, false);
+  const text = JSON.stringify(normalized, null, indent);
+  return text ?? "null";
+}
+function normalizeJsonValue(value, inArray) {
+  if (value === undefined)
+    return inArray ? null : undefined;
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => normalizeJsonValue(item, true));
+  const out = {};
+  for (const [key, val] of Object.entries(value)) {
+    const normalized = normalizeJsonValue(val, false);
+    if (normalized !== undefined)
+      out[key] = normalized;
+  }
+  return out;
+}
 function highlightLine(line) {
   let result = "";
   let lastIndex = 0;
@@ -3396,14 +3112,18 @@ function highlightLine(line) {
       result += C.gray + text + C.reset;
     } else if (g.dstring || g.sstring) {
       result += C.green + text + C.reset;
+    } else if (g.objKey) {
+      result += C.magenta + text + C.reset;
     } else if (g.keyword) {
-      result += C.boldBlue + text + C.reset;
+      result += C.keyword + text + C.reset;
     } else if (g.literal) {
       result += C.yellow + text + C.reset;
     } else if (g.typePred) {
       result += C.cyan + text + C.reset;
     } else if (g.num) {
       result += C.cyan + text + C.reset;
+    } else if (g.identifier) {
+      result += C.blue + text + C.reset;
     } else {
       result += text;
     }
@@ -3465,7 +3185,7 @@ function highlightRexc(text) {
         i++;
         break;
       case "%":
-        out += C.boldBlue + prefix + tag + C.reset;
+        out += C.keyword + prefix + tag + C.reset;
         i++;
         break;
       case "$":
@@ -3491,6 +3211,7 @@ function highlightRexc(text) {
         break;
       }
       case "=":
+      case "/":
       case "~":
         out += C.red + prefix + tag + C.reset;
         i++;
@@ -3502,11 +3223,11 @@ function highlightRexc(text) {
       case ">":
       case "<":
       case "#":
-        out += C.boldBlue + prefix + tag + C.reset;
+        out += C.keyword + prefix + tag + C.reset;
         i++;
         break;
       case ";":
-        out += C.boldBlue + prefix + tag + C.reset;
+        out += C.keyword + prefix + tag + C.reset;
         i++;
         break;
       case "^":
@@ -3530,6 +3251,23 @@ function highlightRexc(text) {
   }
   return out;
 }
+function highlightAuto(text, hint) {
+  if (hint === "rexc")
+    return highlightRexc(text);
+  if (hint === "rex")
+    return text.split(`
+`).map((line) => highlightLine(line)).join(`
+`);
+  try {
+    const match = grammar.match(text);
+    if (match.succeeded()) {
+      return text.split(`
+`).map((line) => highlightLine(line)).join(`
+`);
+    }
+  } catch {}
+  return highlightRexc(text);
+}
 function highlightJSON(json) {
   let result = "";
   let lastIndex = 0;
@@ -3593,23 +3331,18 @@ 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;
 }
-function formatResult(value) {
-  let text;
-  try {
-    text = stringify(value, { maxWidth: 60 });
-  } catch {
-    text = String(value);
-  }
-  return `${C.gray}→${C.reset} ${highlightLine(text)}`;
-}
-function formatVarState(vars) {
+function formatVarState(vars, format) {
   const entries = Object.entries(vars);
   if (entries.length === 0)
     return "";
+  if (format === "json") {
+    const rendered = highlightJSON(formatJson(vars, 2));
+    return `${C.dim}  vars:${C.reset} ${rendered}`;
+  }
   const MAX_LINE = 70;
   const MAX_VALUE = 30;
   const parts = [];
@@ -3634,8 +3367,31 @@ function formatVarState(vars) {
   }
   return `${C.dim}  ${parts.join(", ")}${C.reset}`;
 }
+function renderValue(value, format, kind) {
+  if (format === "json") {
+    return highlightJSON(formatJson(value, 2));
+  }
+  if (kind === "source") {
+    return highlightAuto(String(value ?? ""));
+  }
+  if (kind === "rexc") {
+    return highlightRexc(String(value ?? ""));
+  }
+  return highlightLine(stringify(value, { maxWidth: 120 }));
+}
 function completer(state) {
   return (line) => {
+    if (line.startsWith(".file ")) {
+      return completeFilePath(line, 6);
+    }
+    if (line.startsWith(".cat ")) {
+      return completeFilePath(line, 5);
+    }
+    if (line.startsWith(".") && !line.includes(" ")) {
+      const partial2 = line.trim();
+      const matches = DOT_COMMANDS.filter((cmd) => cmd.startsWith(partial2));
+      return [matches, line];
+    }
     const match = line.match(/[a-zA-Z_][a-zA-Z0-9_.-]*$/);
     const partial = match ? match[0] : "";
     if (!partial)
@@ -3646,45 +3402,92 @@ function completer(state) {
     return [hits, partial];
   };
 }
-function handleDotCommand(cmd, state, rl) {
+function completeFilePath(line, prefixLength) {
+  const raw = line.slice(prefixLength);
+  const trimmed = raw.trimStart();
+  const quote = trimmed.startsWith('"') || trimmed.startsWith("'") ? trimmed[0] : "";
+  const pathPart = quote ? trimmed.slice(1) : trimmed;
+  const endsWithSlash = pathPart.endsWith("/");
+  const rawDir = endsWithSlash ? pathPart.slice(0, -1) : pathPart;
+  const baseName = endsWithSlash ? "" : rawDir.includes("/") ? basename(rawDir) : rawDir;
+  const dirPart = endsWithSlash ? rawDir || "." : rawDir.includes("/") ? dirname(rawDir) : ".";
+  const dirPath = resolve(dirPart);
+  let entries = [];
+  try {
+    entries = readdirSync(dirPath);
+  } catch {
+    return [[], ""];
+  }
+  const prefix = dirPart === "." ? "" : `${dirPart}/`;
+  const matches = entries.filter((entry) => entry.startsWith(baseName)).map((entry) => {
+    const fullPath = resolve(dirPath, entry);
+    let suffix = "";
+    try {
+      if (statSync(fullPath).isDirectory())
+        suffix = "/";
+    } catch {
+      suffix = "";
+    }
+    return `${quote}${prefix}${entry}${suffix}`;
+  });
+  return [matches, trimmed];
+}
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+async function handleDotCommand(cmd, state, rl, runSource, updatePromptStyles) {
   function toggleLabel(on) {
     return on ? `${C.green}on${C.reset}` : `${C.dim}off${C.reset}`;
   }
   switch (cmd) {
     case ".help":
       console.log([
-        `${C.boldBlue}Rex REPL Commands:${C.reset}`,
-        "  .help   Show this help message",
-        "  .vars   Show all current variables",
-        "  .clear  Clear all variables",
-        "  .ir     Toggle showing IR JSON after parsing",
-        "  .rexc   Toggle showing compiled rexc before execution",
-        "  .opt    Toggle IR optimizations",
-        "  .exit   Exit the REPL",
+        `${C.keyword}Rex REPL Commands:${C.reset}`,
+        "  .help         Show this help message",
+        "  .file <path>  Load and execute a Rex file",
+        "  .cat <path>   Print a Rex/rexc file with highlighting",
+        "  .expr         Toggle showing expression results",
+        "  .source       Toggle showing input source",
+        "  .vars         Toggle showing variable summary",
+        "  .vars!        Show all current variables",
+        "  .clear        Clear all variables",
+        "  .ir           Toggle showing IR JSON after parsing",
+        "  .rexc         Toggle showing compiled rexc before execution",
+        "  .opt          Toggle IR optimizations",
+        "  .json         Toggle JSON output format",
+        "  .color        Toggle ANSI color output",
+        "  .exit         Exit the REPL",
         "",
         "Enter Rex expressions to evaluate them.",
         "Multi-line: open brackets or do/end blocks continue on the next line.",
         "Ctrl-C cancels multi-line input.",
-        "Ctrl-D exits."
+        "Ctrl-D exits.",
+        "",
+        "Outputs are printed as labeled blocks when enabled."
       ].join(`
 `));
-      return true;
-    case ".ir":
-      state.showIR = !state.showIR;
-      console.log(`${C.dim}  IR display: ${toggleLabel(state.showIR)}${C.reset}`);
-      return true;
-    case ".rexc":
-      state.showRexc = !state.showRexc;
-      console.log(`${C.dim}  Rexc display: ${toggleLabel(state.showRexc)}${C.reset}`);
-      return true;
-    case ".opt":
-      state.optimize = !state.optimize;
-      console.log(`${C.dim}  Optimizations: ${toggleLabel(state.optimize)}${C.reset}`);
-      return true;
-    case ".vars": {
+      return "handled";
+    case ".expr":
+      state.showExpr = !state.showExpr;
+      console.log(`${C.dim}  Expression output: ${toggleLabel(state.showExpr)}${C.reset}`);
+      return "handled";
+    case ".source":
+      state.showSource = !state.showSource;
+      console.log(`${C.dim}  Source output: ${toggleLabel(state.showSource)}${C.reset}`);
+      return "handled";
+    case ".vars":
+      state.showVars = !state.showVars;
+      console.log(`${C.dim}  Variable summary: ${toggleLabel(state.showVars)}${C.reset}`);
+      return "handled";
+    case ".vars!": {
       const entries = Object.entries(state.vars);
       if (entries.length === 0) {
         console.log(`${C.dim}  (no variables)${C.reset}`);
+      } else if (state.outputFormat === "json") {
+        console.log(highlightJSON(formatJson(state.vars, 2)));
       } else {
         for (const [key, val] of entries) {
           let valStr;
@@ -3696,42 +3499,118 @@ function handleDotCommand(cmd, state, rl) {
           console.log(`  ${key} = ${highlightLine(valStr)}`);
         }
       }
-      return true;
+      return "handled";
     }
+    case ".ir":
+      state.showIR = !state.showIR;
+      console.log(`${C.dim}  IR display: ${toggleLabel(state.showIR)}${C.reset}`);
+      return "handled";
+    case ".rexc":
+      state.showRexc = !state.showRexc;
+      console.log(`${C.dim}  Rexc display: ${toggleLabel(state.showRexc)}${C.reset}`);
+      return "handled";
+    case ".opt":
+      state.optimize = !state.optimize;
+      console.log(`${C.dim}  Optimizations: ${toggleLabel(state.optimize)}${C.reset}`);
+      return "handled";
+    case ".json":
+      state.outputFormat = state.outputFormat === "json" ? "rex" : "json";
+      console.log(`${C.dim}  Output format: ${state.outputFormat}${C.reset}`);
+      return "handled";
+    case ".color":
+      setColorEnabled(!colorEnabled);
+      updatePromptStyles();
+      console.log(`${C.dim}  Color output: ${toggleLabel(colorEnabled)}${C.reset}`);
+      return "handled";
     case ".clear":
       state.vars = {};
       state.refs = {};
       console.log(`${C.dim}  Variables cleared.${C.reset}`);
-      return true;
+      return "handled";
     case ".exit":
       rl.close();
-      return true;
+      return "handled-noprompt";
     default:
+      if (cmd.startsWith(".cat ")) {
+        const rawPath = cmd.slice(5).trim();
+        if (!rawPath) {
+          console.log(`${C.red}  Missing file path. Usage: .cat <path>${C.reset}`);
+          return "handled";
+        }
+        const filePath = resolve(stripQuotes(rawPath));
+        try {
+          const source = readFileSync(filePath, "utf8");
+          const hint = filePath.endsWith(".rexc") ? "rexc" : filePath.endsWith(".rex") ? "rex" : undefined;
+          console.log(highlightAuto(source, hint));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.log(`${C.red}  File error: ${message}${C.reset}`);
+        }
+        return "handled";
+      }
+      if (cmd.startsWith(".file ")) {
+        const rawPath = cmd.slice(6).trim();
+        if (!rawPath) {
+          console.log(`${C.red}  Missing file path. Usage: .file <path>${C.reset}`);
+          return "handled";
+        }
+        const filePath = resolve(stripQuotes(rawPath));
+        try {
+          const source = readFileSync(filePath, "utf8");
+          runSource(source);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.log(`${C.red}  File error: ${message}${C.reset}`);
+        }
+        return "handled";
+      }
       if (cmd.startsWith(".")) {
         console.log(`${C.red}  Unknown command: ${cmd}. Type .help for available commands.${C.reset}`);
-        return true;
+        return "handled";
       }
-      return false;
+      return "unhandled";
   }
 }
 async function startRepl() {
-  const state = { vars: {}, refs: {}, showIR: false, showRexc: false, optimize: false };
+  const state = {
+    vars: {},
+    refs: {},
+    showIR: false,
+    showRexc: false,
+    optimize: false,
+    showExpr: true,
+    showVars: false,
+    showSource: false,
+    outputFormat: "rex"
+  };
   let multiLineBuffer = "";
   const PRIMARY_PROMPT = "rex> ";
   const CONT_PROMPT = "...  ";
-  const STYLED_PRIMARY = `${C.boldBlue}rex${C.reset}> `;
-  const STYLED_CONT = `${C.dim}...${C.reset}  `;
   let currentPrompt = PRIMARY_PROMPT;
-  let styledPrompt = STYLED_PRIMARY;
-  console.log(`${C.boldBlue}Rex${C.reset} v${version} — type ${C.dim}.help${C.reset} for commands`);
+  let styledPrompt = "";
+  let styledPrimary = "";
+  let styledCont = "";
+  function updatePromptStyles() {
+    styledPrimary = `${C.keyword}rex${C.reset}> `;
+    styledCont = `${C.dim}...${C.reset}  `;
+    styledPrompt = currentPrompt === PRIMARY_PROMPT ? styledPrimary : styledCont;
+  }
+  updatePromptStyles();
+  console.log(`${C.keyword}Rex${C.reset} v${version} — type ${C.dim}.help${C.reset} for commands`);
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
     prompt: PRIMARY_PROMPT,
-    historySize: 500,
+    historySize: HISTORY_LIMIT,
     completer: completer(state),
     terminal: true
   });
+  try {
+    const historyText = readFileSync(HISTORY_PATH, "utf8");
+    const lines = historyText.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const recent = lines.slice(-HISTORY_LIMIT);
+    rl.history = recent.reverse();
+  } catch {}
   process.stdin.on("keypress", () => {
     process.nextTick(() => {
       if (!rl.line && rl.line !== "")
@@ -3753,7 +3632,7 @@ async function startRepl() {
     if (multiLineBuffer) {
       multiLineBuffer = "";
       currentPrompt = PRIMARY_PROMPT;
-      styledPrompt = STYLED_PRIMARY;
+      styledPrompt = styledPrimary;
       rl.setPrompt(PRIMARY_PROMPT);
       process.stdout.write(`
 `);
@@ -3765,50 +3644,33 @@ async function startRepl() {
   });
   function resetPrompt() {
     currentPrompt = PRIMARY_PROMPT;
-    styledPrompt = STYLED_PRIMARY;
+    styledPrompt = styledPrimary;
     rl.setPrompt(PRIMARY_PROMPT);
     rl.prompt();
   }
-  rl.on("line", (line) => {
-    const trimmed = line.trim();
-    if (!multiLineBuffer && trimmed.startsWith(".")) {
-      if (handleDotCommand(trimmed, state, rl)) {
-        rl.prompt();
-        return;
-      }
-    }
-    multiLineBuffer += (multiLineBuffer ? `
-` : "") + line;
-    if (multiLineBuffer.trim() === "") {
-      multiLineBuffer = "";
-      rl.prompt();
-      return;
-    }
-    if (isIncomplete(multiLineBuffer)) {
-      currentPrompt = CONT_PROMPT;
-      styledPrompt = STYLED_CONT;
-      rl.setPrompt(CONT_PROMPT);
-      rl.prompt();
-      return;
-    }
-    const source = multiLineBuffer;
-    multiLineBuffer = "";
+  function runSource(source) {
     const match = grammar.match(source);
     if (!match.succeeded()) {
-      console.log(`${C.red}  ${match.message}${C.reset}`);
-      resetPrompt();
+      const message = formatParseError(source, match);
+      console.log(`${C.red}  ${message}${C.reset}`);
       return;
     }
     try {
-      const ir = parseToIR(source);
-      const lowered = state.optimize ? optimizeIR(ir) : ir;
-      if (state.showIR) {
-        console.log(`${C.dim}  IR:${C.reset} ${highlightJSON(JSON.stringify(lowered))}`);
+      const outputs = {};
+      if (state.showSource)
+        outputs.source = source;
+      const isRex = grammar.match(source).succeeded();
+      if (!isRex && state.showIR) {
+        console.log(`${C.red}  IR output is only available for Rex source.${C.reset}`);
       }
-      const rexc = compile(source, { optimize: state.optimize });
-      if (state.showRexc) {
-        console.log(`${C.dim}  rexc:${C.reset} ${highlightRexc(rexc)}`);
+      const rexc = isRex ? compile(source, { optimize: state.optimize }) : source;
+      if (state.showIR && isRex) {
+        const ir = parseToIR(source);
+        const lowered = state.optimize ? optimizeIR(ir) : ir;
+        outputs.ir = lowered;
       }
+      if (state.showRexc)
+        outputs.rexc = rexc;
       const result = evaluateRexc(rexc, {
         vars: { ...state.vars },
         refs: { ...state.refs },
@@ -3816,10 +3678,17 @@ async function startRepl() {
       });
       state.vars = result.state.vars;
       state.refs = result.state.refs;
-      console.log(formatResult(result.value));
-      const varLine = formatVarState(state.vars);
-      if (varLine)
-        console.log(varLine);
+      if (state.showExpr)
+        outputs.result = result.value;
+      if (state.showVars)
+        outputs.vars = state.vars;
+      const order = ["source", "ir", "rexc", "vars", "result"];
+      for (const key of order) {
+        const value = outputs[key];
+        if (value === undefined)
+          continue;
+        console.log(`${C.gray}  ${key}:${C.reset} ${renderValue(value, state.outputFormat, key)}`);
+      }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (message.includes("Gas limit exceeded")) {
@@ -3828,32 +3697,58 @@ async function startRepl() {
         console.log(`${C.red}  Error: ${message}${C.reset}`);
       }
     }
+  }
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!multiLineBuffer && trimmed.startsWith(".")) {
+      const result = await handleDotCommand(trimmed, state, rl, runSource, updatePromptStyles);
+      if (result === "handled") {
+        rl.prompt();
+        return;
+      }
+      if (result === "handled-noprompt")
+        return;
+    }
+    multiLineBuffer += (multiLineBuffer ? `
+` : "") + line;
+    if (multiLineBuffer.trim() === "") {
+      multiLineBuffer = "";
+      rl.prompt();
+      return;
+    }
+    if (isIncomplete(multiLineBuffer)) {
+      currentPrompt = CONT_PROMPT;
+      styledPrompt = styledCont;
+      rl.setPrompt(CONT_PROMPT);
+      rl.prompt();
+      return;
+    }
+    const source = multiLineBuffer;
+    multiLineBuffer = "";
+    runSource(source);
     resetPrompt();
   });
   rl.on("close", () => {
+    try {
+      const history = rl.history ?? [];
+      const trimmed = history.slice().reverse().filter((line) => line.trim().length > 0).slice(-HISTORY_LIMIT);
+      writeFileSync(HISTORY_PATH, `${trimmed.join(`
+`)}
+`, "utf8");
+    } catch {}
     process.exit(0);
   });
   rl.prompt();
 }
-var req, version, C, TOKEN_RE, REXC_DIGITS, JSON_TOKEN_RE, KEYWORDS, GAS_LIMIT = 1e7;
+var req, version, colorEnabled, C, TOKEN_RE, REXC_DIGITS, JSON_TOKEN_RE, KEYWORDS, DOT_COMMANDS, GAS_LIMIT = 1e7, HISTORY_LIMIT = 1000, HISTORY_PATH;
 var init_rex_repl = __esm(() => {
   init_rex();
   init_rexc_interpreter();
   req = createRequire2(import.meta.url);
   ({ version } = req("./package.json"));
-  C = {
-    reset: "\x1B[0m",
-    bold: "\x1B[1m",
-    dim: "\x1B[2m",
-    red: "\x1B[31m",
-    green: "\x1B[32m",
-    yellow: "\x1B[33m",
-    blue: "\x1B[34m",
-    cyan: "\x1B[36m",
-    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|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;
+  colorEnabled = process.stdout.isTTY;
+  C = createColors(colorEnabled);
+  TOKEN_RE = /(?<blockComment>\/\*[\s\S]*?(?:\*\/|$))|(?<lineComment>\/\/[^\n]*)|(?<dstring>"(?:[^"\\]|\\.)*"?)|(?<sstring>'(?:[^'\\]|\\.)*'?)|(?<objKey>\b[A-Za-z_][A-Za-z0-9_-]*\b)(?=\s*:)|(?<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)|(?<identifier>\b[A-Za-z_][A-Za-z0-9_.-]*\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 = [
@@ -3867,6 +3762,7 @@ var init_rex_repl = __esm(() => {
     "of",
     "and",
     "or",
+    "nor",
     "else",
     "break",
     "continue",
@@ -3884,20 +3780,49 @@ var init_rex_repl = __esm(() => {
     "array",
     "boolean"
   ];
+  DOT_COMMANDS = [
+    ".help",
+    ".file",
+    ".cat",
+    ".expr",
+    ".source",
+    ".vars",
+    ".vars!",
+    ".clear",
+    ".ir",
+    ".rexc",
+    ".opt",
+    ".json",
+    ".color",
+    ".exit"
+  ];
+  HISTORY_PATH = resolve(homedir(), ".rex_history");
 });
 
 // rex-cli.ts
 init_rex();
 init_rexc_interpreter();
-import { dirname, resolve } from "node:path";
+init_rex_repl();
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
 import { readFile, writeFile } from "node:fs/promises";
 function parseArgs(argv) {
   const options = {
+    sources: [],
     compile: false,
     ir: false,
     minifyNames: false,
     dedupeValues: false,
-    help: false
+    help: false,
+    cat: false,
+    showSource: false,
+    showExpr: true,
+    showIR: false,
+    showRexc: false,
+    showVars: false,
+    color: process.stdout.isTTY,
+    colorExplicit: false,
+    showExprExplicit: false,
+    format: "rex"
   };
   for (let index = 0;index < argv.length; index += 1) {
     const arg = argv[index];
@@ -3907,6 +3832,60 @@ function parseArgs(argv) {
       options.help = true;
       continue;
     }
+    if (arg === "--cat") {
+      options.cat = true;
+      continue;
+    }
+    if (arg === "--show-source") {
+      options.showSource = true;
+      continue;
+    }
+    if (arg === "--show-expr") {
+      options.showExpr = true;
+      options.showExprExplicit = true;
+      continue;
+    }
+    if (arg === "--no-expr") {
+      options.showExpr = false;
+      options.showExprExplicit = true;
+      continue;
+    }
+    if (arg === "--show-ir") {
+      options.showIR = true;
+      continue;
+    }
+    if (arg === "--show-rexc") {
+      options.showRexc = true;
+      continue;
+    }
+    if (arg === "--show-vars") {
+      options.showVars = true;
+      continue;
+    }
+    if (arg === "--json") {
+      options.format = "json";
+      continue;
+    }
+    if (arg === "--format") {
+      const value = argv[index + 1];
+      if (!value)
+        throw new Error("Missing value for --format");
+      if (value !== "rex" && value !== "json")
+        throw new Error("--format must be 'rex' or 'json'");
+      options.format = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--color") {
+      options.color = true;
+      options.colorExplicit = true;
+      continue;
+    }
+    if (arg === "--no-color") {
+      options.color = false;
+      options.colorExplicit = true;
+      continue;
+    }
     if (arg === "--compile" || arg === "-c") {
       options.compile = true;
       continue;
@@ -3938,7 +3917,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;
     }
@@ -3946,7 +3925,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;
     }
@@ -3959,9 +3938,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}`);
@@ -3979,15 +3956,39 @@ 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",
-    "      --ir              Output lowered IR as JSON",
+    "  (default)             Evaluate and output result",
+    "  -c, --compile         Show rexc only (same as --show-rexc --no-expr)",
+    "      --ir              Show IR only (same as --show-ir --no-expr)",
+    "      --cat             Print input with Rex highlighting",
+    "      --show-source     Show input source text",
+    "      --show-expr       Show expression result",
+    "      --no-expr         Hide expression result",
+    "      --show-ir         Show IR JSON",
+    "      --show-rexc       Show rexc bytecode",
+    "      --show-vars       Show variable state",
+    "",
+    "Output formatting:",
+    "      --format <type>   Output format: rex|json (default: rex)",
+    "      --json            Shortcut for --format json",
+    "      --color           Force color output",
+    "      --no-color        Disable color output",
+    "",
+    "TTY vs non-TTY:",
+    "  TTY output prints labeled blocks when multiple outputs are selected.",
+    "  Non-TTY output emits a single value (object if multiple outputs).",
     "",
     "Compile options:",
     "  -m, --minify-names    Minify local variable names",
@@ -4008,12 +4009,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)
@@ -4021,8 +4027,15 @@ 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");
+  const configPath = resolve2(folderPath, ".config.rex");
   try {
     return parse(await readFile(configPath, "utf8"));
   } catch (error) {
@@ -4032,36 +4045,167 @@ 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 ? dirname2(resolve2(filePath)) : process.cwd();
   return loadDomainConfigFromFolder(baseFolder);
 }
+function formatJson2(value, indent = 2) {
+  const normalized = normalizeJsonValue2(value, false);
+  const text = JSON.stringify(normalized, null, indent);
+  return text ?? "null";
+}
+function normalizeJsonValue2(value, inArray) {
+  if (value === undefined)
+    return inArray ? null : undefined;
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeJsonValue2(item, true));
+  }
+  const out = {};
+  for (const [key, val] of Object.entries(value)) {
+    const normalized = normalizeJsonValue2(val, false);
+    if (normalized !== undefined)
+      out[key] = normalized;
+  }
+  return out;
+}
+function isRexSource(source) {
+  try {
+    return grammar.match(source).succeeded();
+  } catch {
+    return false;
+  }
+}
 async function main() {
   const options = parseArgs(process.argv.slice(2));
   if (options.help) {
     console.log(usage());
     return;
   }
-  const hasSource = options.expr || options.file || !process.stdin.isTTY;
+  setColorEnabled(options.color);
+  if (options.cat) {
+    const source2 = await resolveSource(options);
+    const hasRexc = options.sources.some((seg) => seg.type === "file" && seg.path.endsWith(".rexc"));
+    const hasRex = options.sources.some((seg) => seg.type === "file" && seg.path.endsWith(".rex"));
+    const hint = hasRexc && !hasRex ? "rexc" : hasRex && !hasRexc ? "rex" : undefined;
+    const output2 = process.stdout.isTTY && options.color ? highlightAuto(source2, hint) : source2;
+    if (options.out) {
+      await writeFile(options.out, `${output2}
+`, "utf8");
+      return;
+    }
+    console.log(output2);
+    return;
+  }
+  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();
     return;
   }
   const source = await resolveSource(options);
-  let output;
+  const sourceIsRex = isRexSource(source);
+  if (options.compile) {
+    if (!sourceIsRex)
+      throw new Error("--compile requires Rex source");
+    options.showRexc = true;
+    if (!options.showExprExplicit)
+      options.showExpr = false;
+  }
   if (options.ir) {
-    output = JSON.stringify(parseToIR(source), null, 2);
-  } else if (options.compile) {
+    if (!sourceIsRex)
+      throw new Error("--ir requires Rex source");
+    options.showIR = true;
+    if (!options.showExprExplicit)
+      options.showExpr = false;
+  }
+  const outputFlags = [options.showSource, options.showExpr, options.showIR, options.showRexc, options.showVars].filter(Boolean).length;
+  if (outputFlags === 0) {
+    throw new Error("No output selected. Use --show-source, --show-expr, --show-ir, --show-rexc, or --show-vars.");
+  }
+  const humanMode = process.stdout.isTTY && options.color;
+  const outputs = {};
+  if (options.showSource)
+    outputs.source = source;
+  if (!sourceIsRex && options.showIR) {
+    throw new Error("--show-ir is only available for Rex source");
+  }
+  if (options.showIR) {
+    outputs.ir = parseToIR(source);
+  }
+  if (options.showRexc) {
     const domainConfig = await resolveDomainConfig(options);
-    output = compile(source, {
+    outputs.rexc = sourceIsRex ? compile(source, {
       minifyNames: options.minifyNames,
       dedupeValues: options.dedupeValues,
       dedupeMinBytes: options.dedupeMinBytes,
       domainConfig
-    });
+    }) : source;
+  }
+  if (options.showExpr || options.showVars) {
+    const result = sourceIsRex ? evaluateSource(source) : evaluateRexc(source);
+    if (options.showExpr)
+      outputs.result = result.value;
+    if (options.showVars)
+      outputs.vars = result.state.vars;
+  }
+  const order = ["source", "ir", "rexc", "vars", "result"];
+  const selected = order.filter((key) => outputs[key] !== undefined);
+  function formatValue(value, kind) {
+    if (kind === "source") {
+      const raw2 = String(value ?? "");
+      if (options.format === "json") {
+        const json = formatJson2(raw2, 2);
+        return humanMode && options.color ? highlightJSON(json) : json;
+      }
+      return humanMode && options.color ? highlightAuto(raw2) : raw2;
+    }
+    if (kind === "rexc" && humanMode) {
+      const raw2 = String(value ?? "");
+      return options.color ? highlightAuto(raw2, "rexc") : raw2;
+    }
+    if (options.format === "json") {
+      const raw2 = formatJson2(value, 2);
+      return humanMode && options.color ? highlightJSON(raw2) : raw2;
+    }
+    if (kind === "rexc") {
+      const raw2 = stringify(String(value ?? ""));
+      return humanMode && options.color ? highlightLine(raw2) : raw2;
+    }
+    const raw = stringify(value);
+    return humanMode && options.color ? highlightLine(raw) : raw;
+  }
+  let output;
+  if (humanMode) {
+    const header = options.color ? "\x1B[90m" : "";
+    const reset = options.color ? "\x1B[0m" : "";
+    const lines = [];
+    for (const key of order) {
+      const value = outputs[key];
+      if (value === undefined)
+        continue;
+      lines.push(`${header}${key}:${reset} ${formatValue(value, key)}`);
+    }
+    output = lines.join(`
+`);
   } else {
-    const { value } = evaluateSource(source);
-    output = stringify(value);
+    let value;
+    if (selected.length === 1) {
+      const only = selected[0];
+      if (!only)
+        throw new Error("No output selected.");
+      value = outputs[only];
+    } else {
+      const out = {};
+      for (const key of order) {
+        const v = outputs[key];
+        if (v !== undefined)
+          out[key] = v;
+      }
+      value = out;
+    }
+    output = options.format === "json" ? formatJson2(value, 2) : stringify(value);
   }
   if (options.out) {
     await writeFile(options.out, `${output}