@nudojs/cli 0.2.0 → 0.2.1

package/src/__tests__/mock-rest-debug.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect } from "vitest";
+import { parse, extractDirectives, type CaseDirective, parseTypeValueExpr } from "@nudojs/parser";
+import { typeValueToString, createEnvironment, T } from "@nudojs/core";
+import { evaluateFunctionFull } from "../evaluator.js";
+
+function inferWithMocks(source: string): { name: string; caseName: string; result: string }[] {
+  const ast = parse(source);
+  const directives = extractDirectives(ast);
+  const env = createEnvironment();
+  const results: { name: string; caseName: string; result: string }[] = [];
+
+  for (const fn of directives) {
+    for (const d of fn.directives) {
+      if (d.kind === "mock") {
+        if (d.arrowFn) {
+          const fnType = T.fn(d.arrowFn.params, d.arrowFn.body, env);
+          (fnType as any)._paramPatterns = d.arrowFn.paramPatterns;
+          env.bind(d.name, fnType);
+        } else if (d.expression) {
+          env.bind(d.name, parseTypeValueExpr(d.expression));
+        }
+      }
+    }
+
+    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
+    for (const dir of caseDirectives) {
+      const result = evaluateFunctionFull(fn.node, dir.args, env);
+      results.push({
+        name: fn.name,
+        caseName: dir.name,
+        result: typeValueToString(result.value),
+      });
+    }
+  }
+  return results;
+}
+
+describe("Rest Parameter Debug", () => {
+  it("rest param: collect args into tuple", () => {
+    const results = inferWithMocks(`
+// @nudo:mock sum = (...args) => args.length
+// @nudo:case "three" (1, 2, 3)
+function countArgs() {
+  return sum(1, 2, 3);
+}
+`);
+    console.log("Rest param result:", results[0].result);
+    expect(results[0].result).toBe("3");
+  });
+
+  it("rest param: spread array", () => {
+    const results = inferWithMocks(`
+// @nudo:mock sum = (...args) => args.length
+// @nudo:case "arr" ([1, 2, 3])
+function countFromArr(arr) {
+  return sum(...arr);
+}
+`);
+    console.log("Spread array result:", results[0].result);
+    expect(results[0].result).toBe("3");
+  });
+
+  it("rest param: access elements", () => {
+    const results = inferWithMocks(`
+// @nudo:mock getFirst = (...args) => args[0]
+// @nudo:case "nums" (10, 20, 30)
+function first() {
+  return getFirst(10, 20, 30);
+}
+`);
+    console.log("First element result:", results[0].result);
+    expect(results[0].result).toBe("10");
+  });
+
+  it("rest param: sum values", () => {
+    const results = inferWithMocks(`
+// @nudo:mock add = (...args) => args[0] + args[1] + args[2]
+// @nudo:case "nums" (1, 2, 3)
+function addThree() {
+  return add(1, 2, 3);
+}
+`);
+    console.log("Sum result:", results[0].result);
+    expect(results[0].result).toBe("6");
+  });
+
+  it("named + rest params", () => {
+    const results = inferWithMocks(`
+// @nudo:mock log = (first, ...rest) => rest.length
+// @nudo:case "args" ("a", "b", "c", "d")
+function logCount() {
+  return log("a", "b", "c", "d");
+}
+`);
+    console.log("Named + rest result:", results[0].result);
+    expect(results[0].result).toBe("3");
+  });
+
+  it("rest param with reduce", () => {
+    const results = inferWithMocks(`
+// @nudo:mock sum = (...args) => args.reduce((a, b) => a + b, 0)
+// @nudo:case "nums" (1, 2, 3)
+function total() {
+  return sum(1, 2, 3);
+}
+`);
+    console.log("Reduce result:", results[0].result);
+    expect(results[0].result).toBe("6");
+  });
+});

package/src/__tests__/mock-rest-edge.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from "vitest";
+import { parse, extractDirectives, type CaseDirective, parseTypeValueExpr } from "@nudojs/parser";
+import { typeValueToString, createEnvironment, T } from "@nudojs/core";
+import { evaluateFunctionFull } from "../evaluator.js";
+
+function inferWithMocks(source: string): { name: string; caseName: string; result: string }[] {
+  const ast = parse(source);
+  const directives = extractDirectives(ast);
+  const env = createEnvironment();
+  const results: { name: string; caseName: string; result: string }[] = [];
+
+  for (const fn of directives) {
+    for (const d of fn.directives) {
+      if (d.kind === "mock") {
+        if (d.arrowFn) {
+          const fnType = T.fn(d.arrowFn.params, d.arrowFn.body, env);
+          (fnType as any)._paramPatterns = d.arrowFn.paramPatterns;
+          env.bind(d.name, fnType);
+        } else if (d.expression) {
+          env.bind(d.name, parseTypeValueExpr(d.expression));
+        }
+      }
+    }
+
+    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
+    for (const dir of caseDirectives) {
+      const result = evaluateFunctionFull(fn.node, dir.args, env);
+      results.push({
+        name: fn.name,
+        caseName: dir.name,
+        result: typeValueToString(result.value),
+      });
+    }
+  }
+  return results;
+}
+
+describe("Rest Parameter Edge Cases", () => {
+  it("rest param: no args passed", () => {
+    const results = inferWithMocks(`
+// @nudo:mock count = (...args) => args.length
+// @nudo:case "empty" ()
+function noArgs() {
+  return count();
+}
+`);
+    console.log("No args result:", results[0].result);
+    expect(results[0].result).toBe("0");
+  });
+
+  it("rest param: single arg", () => {
+    const results = inferWithMocks(`
+// @nudo:mock first = (...args) => args[0]
+// @nudo:case "one" (42)
+function oneArg() {
+  return first(42);
+}
+`);
+    console.log("Single arg result:", results[0].result);
+    expect(results[0].result).toBe("42");
+  });
+
+  it("rest param: spread with mock inside higher-order fn", () => {
+    const results = inferWithMocks(`
+// @nudo:mock fn = (x) => x * 2
+// @nudo:case "nums" ([1, 2, 3])
+function applyAll(arr) {
+  return arr.map(fn);
+}
+`);
+    console.log("Map result:", results[0].result);
+    expect(results[0].result).toBe("[2, 4, 6]");
+  });
+
+  it("rest param: destructure from tuple", () => {
+    const results = inferWithMocks(`
+// @nudo:mock swap = ([a, b]) => [b, a]
+// @nudo:case "pair" ([1, 2])
+function swapPair(pair) {
+  return swap(pair);
+}
+`);
+    console.log("Destructure result:", results[0].result);
+    expect(results[0].result).toBe("[2, 1]");
+  });
+
+  it("rest param: nested arrow functions", () => {
+    const results = inferWithMocks(`
+// @nudo:mock curry = (a) => (b) => a + b
+// @nudo:case "num" (5)
+function curried(x) {
+  const add5 = curry(x);
+  return add5(10);
+}
+`);
+    console.log("Curry result:", results[0].result);
+    expect(results[0].result).toBe("15");
+  });
+
+  it("rest param: mock returning object", () => {
+    const results = inferWithMocks(`
+// @nudo:mock make = (x) => ({ value: x, doubled: x * 2 })
+// @nudo:case "num" (5)
+function makeObj(x) {
+  return make(x);
+}
+`);
+    console.log("Object result:", results[0].result);
+    expect(results[0].result).toBe('{ value: 5, doubled: 10 }');
+  });
+
+  it("rest param: conditional return (abstract interpretation)", () => {
+    const results = inferWithMocks(`
+// @nudo:mock safe = (x) => x > 0 ? x : 0
+// @nudo:case "pos" (5)
+// @nudo:case "neg" (-3)
+function safeValue(x) {
+  return safe(x);
+}
+`);
+    console.log("Conditional results:", results.map(r => r.result));
+    // Abstract interpretation: x > 0 narrows x to number (>= 1)
+    expect(results[0].result).toBe("number (>= 1)");
+    expect(results[1].result).toBe("0");
+  });
+
+  it("rest param: multiple rest params in chain", () => {
+    const results = inferWithMocks(`
+// @nudo:mock collect = (...args) => args
+// @nudo:mock process = (arr) => arr.length
+// @nudo:case "nums" (1, 2, 3, 4)
+function chain() {
+  const collected = collect(1, 2, 3, 4);
+  return process(collected);
+}
+`);
+    console.log("Chain result:", results[0].result);
+    expect(results[0].result).toBe("4");
+  });
+
+  it("destructure: object pattern", () => {
+    const results = inferWithMocks(`
+// @nudo:mock getFullName = ({first, last}) => first + " " + last
+// @nudo:case "name" ({first: "John", last: "Doe"})
+function fullName(obj) {
+  return getFullName(obj);
+}
+`);
+    console.log("Object destructure result:", results[0].result);
+    expect(results[0].result).toBe('"John Doe"');
+  });
+
+  it("destructure: nested array", () => {
+    const results = inferWithMocks(`
+// @nudo:mock sum = ([a, b]) => a + b
+// @nudo:case "pair" ([3, 7])
+function sumPair(pair) {
+  return sum(pair);
+}
+`);
+    console.log("Nested array result:", results[0].result);
+    expect(results[0].result).toBe("10");
+  });
+
+  it("destructure: mixed params", () => {
+    const results = inferWithMocks(`
+// @nudo:mock process = (x, [a, b]) => x + a + b
+// @nudo:case "mixed" (1, [2, 3])
+function processMixed(x, pair) {
+  return process(x, pair);
+}
+`);
+    console.log("Mixed params result:", results[0].result);
+    expect(results[0].result).toBe("6");
+  });
+});

package/src/__tests__/mock-sinon-runtime.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect } from "vitest";
+import { parse, extractDirectives, type CaseDirective, type MockDirective, parseTypeValueExpr } from "@nudojs/parser";
+import { typeValueToString, createEnvironment, T, mockHelperToTypeValue } from "@nudojs/core";
+import { evaluateFunctionFull } from "../evaluator.js";
+
+function createSinonMock(sinonExpr: any, env: any): any {
+  const body = { type: "BlockStatement", body: [] };
+  const fn = T.fn(["...args"], body, env);
+
+  if (sinonExpr.returnValue) {
+    (fn as any)._directReturn = sinonExpr.returnValue;
+  } else if (sinonExpr.resolvedValue) {
+    (fn as any)._directReturn = T.promise(sinonExpr.resolvedValue);
+  } else if (sinonExpr.rejectedValue) {
+    (fn as any)._directReturn = T.never;
+  } else {
+    (fn as any)._directReturn = T.unknown;
+  }
+  return fn;
+}
+
+function inferWithSinonMocks(source: string): { name: string; caseName: string; result: string }[] {
+  const ast = parse(source);
+  const directives = extractDirectives(ast);
+  const env = createEnvironment();
+  const results: { name: string; caseName: string; result: string }[] = [];
+
+  for (const fn of directives) {
+    for (const d of fn.directives) {
+      if (d.kind === "mock") {
+        if (d.arrowFn) {
+          const fnType = T.fn(d.arrowFn.params, d.arrowFn.body, env);
+          (fnType as any)._paramPatterns = d.arrowFn.paramPatterns;
+          env.bind(d.name, fnType);
+        } else if (d.nudoMock) {
+          const typeVal = mockHelperToTypeValue(d.nudoMock, env);
+          env.bind(d.name, typeVal);
+        } else if (d.sinonExpr) {
+          const mockFn = createSinonMock(d.sinonExpr, env);
+          env.bind(d.name, mockFn);
+        } else if (d.expression) {
+          env.bind(d.name, parseTypeValueExpr(d.expression));
+        }
+      }
+    }
+
+    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
+    for (const dir of caseDirectives) {
+      const result = evaluateFunctionFull(fn.node, dir.args, env);
+      results.push({
+        name: fn.name,
+        caseName: dir.name,
+        result: typeValueToString(result.value),
+      });
+    }
+  }
+  return results;
+}
+
+describe("Sinon Mock Runtime Tests", () => {
+  it("sinon.stub() - basic stub", () => {
+    const results = inferWithSinonMocks(`
+// @nudo:mock fetch = sinon.stub()
+// @nudo:case "call" ("/api/data")
+function getData(url) {
+  return fetch(url);
+}
+`);
+    console.log("sinon.stub() result:", results[0].result);
+    // Stub returns unknown by default
+    expect(results[0].result).toBeDefined();
+  });
+
+  it("sinon.stub().returns() - with return value", () => {
+    const results = inferWithSinonMocks(`
+// @nudo:mock fetch = sinon.stub().returns({ data: "test" })
+// @nudo:case "call" ("/api/data")
+function getData(url) {
+  return fetch(url);
+}
+`);
+    console.log("sinon.stub().returns() result:", results[0].result);
+    expect(results[0].result).toBeDefined();
+  });
+
+  it("sinon.spy() - spy function", () => {
+    const results = inferWithSinonMocks(`
+// @nudo:mock handler = sinon.spy()
+// @nudo:case "event" ("click")
+function processEvent(eventName) {
+  handler(eventName);
+  return eventName;
+}
+`);
+    console.log("sinon.spy() result:", results[0].result);
+    expect(results[0].result).toBe('"click"');
+  });
+
+  it("sinon.mock() - mock function", () => {
+    const results = inferWithSinonMocks(`
+// @nudo:mock service = sinon.mock()
+// @nudo:case "call" ("getData")
+function useService(method) {
+  return service[method]();
+}
+`);
+    console.log("sinon.mock() result:", results[0].result);
+    expect(results[0].result).toBeDefined();
+  });
+
+  it("sinon.stub().resolves() - promise resolution", () => {
+    const results = inferWithSinonMocks(`
+// @nudo:mock fetch = sinon.stub().resolves({ data: "test" })
+// @nudo:case "call" ("/api/data")
+async function getData(url) {
+  return await fetch(url);
+}
+`);
+    console.log("sinon.stub().resolves() result:", results[0].result);
+    expect(results[0].result).toBeDefined();
+  });
+
+  it("sinon.stub().callsFake() - executes the fake with actual args", () => {
+    const results = inferWithSinonMocks(`
+// @nudo:mock transform = sinon.stub().callsFake((x) => ({ v: x }))
+// @nudo:case "direct" (21)
+function applyTransform(x) {
+  return transform(x);
+}
+`);
+    expect(results[0].result).toBe("{ v: 21 }");
+  });
+
+  it("stub().callsFake() (bare form) - same execution semantics as sinon prefix", () => {
+    const results = inferWithSinonMocks(`
+// @nudo:mock transform = stub().callsFake((x) => ({ v: x }))
+// @nudo:case "direct" (21)
+function applyTransform(x) {
+  return transform(x);
+}
+`);
+    expect(results[0].result).toBe("{ v: 21 }");
+  });
+
+  it("sinon.stub().callsFake() value propagates precisely through arr.map HOF", () => {
+    const results = inferWithSinonMocks(`
+// @nudo:mock transform = sinon.stub().callsFake((x) => ({ v: x }))
+// @nudo:case "hof" ([1, 2, 3])
+function mapAll(arr) {
+  return arr.map(transform);
+}
+`);
+    expect(results[0].result).toBe("[{ v: 1 }, { v: 2 }, { v: 3 }]");
+  });
+
+  it("sinon.stub().withArgs().returns() - matched args use the chain return, unmatched fall back", () => {
+    const results = inferWithSinonMocks(`
+// @nudo:mock handler = sinon.stub().withArgs(21).returns("hit")
+// @nudo:case "match" (21)
+// @nudo:case "miss" (22)
+function call(x) {
+  return handler(x);
+}
+`);
+    expect(results[0].result).toBe('"hit"');
+    expect(results[1].result).toBe("unknown");
+  });
+});

package/src/__tests__/narrowing-discriminated.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { T, typeValueToString, createEnvironment } from "@nudojs/core";
+import { parse } from "@nudojs/parser";
+import { narrow } from "../narrowing.ts";
+import type { ExpressionStatement } from "@babel/types";
+
+function getTestExpr(source: string) {
+  const ast = parse(source);
+  const stmt = ast.program.body[0] as ExpressionStatement;
+  return stmt.expression;
+}
+
+describe("narrow: discriminated unions", () => {
+  it("narrows shape.kind === 'circle' to circle member", () => {
+    const env = createEnvironment();
+    const circle = T.object({ kind: T.literal("circle"), radius: T.number });
+    const rect = T.object({ kind: T.literal("rect"), w: T.number, h: T.number });
+    env.bind("shape", T.union(circle, rect));
+    const expr = getTestExpr('shape.kind === "circle"');
+    const [trueEnv, falseEnv] = narrow(expr, env);
+    expect(typeValueToString(trueEnv.lookup("shape"))).toBe('{ kind: "circle", radius: number }');
+    expect(typeValueToString(falseEnv.lookup("shape"))).toBe('{ kind: "rect", w: number, h: number }');
+  });
+
+  it("narrows shape.kind !== 'circle' (inverted)", () => {
+    const env = createEnvironment();
+    const circle = T.object({ kind: T.literal("circle"), radius: T.number });
+    const rect = T.object({ kind: T.literal("rect"), w: T.number, h: T.number });
+    env.bind("shape", T.union(circle, rect));
+    const expr = getTestExpr('shape.kind !== "circle"');
+    const [trueEnv, falseEnv] = narrow(expr, env);
+    expect(typeValueToString(trueEnv.lookup("shape"))).toBe('{ kind: "rect", w: number, h: number }');
+    expect(typeValueToString(falseEnv.lookup("shape"))).toBe('{ kind: "circle", radius: number }');
+  });
+});

package/src/__tests__/narrowing-in-operator.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import { T, typeValueToString, createEnvironment } from "@nudojs/core";
+import { parse } from "@nudojs/parser";
+import { narrow } from "../narrowing.ts";
+import { evaluateProgram } from "../evaluator.ts";
+import type { ExpressionStatement } from "@babel/types";
+
+function getTestExpr(source: string) {
+  const ast = parse(source);
+  const stmt = ast.program.body[0] as ExpressionStatement;
+  return stmt.expression;
+}
+
+describe("narrow: in operator", () => {
+  it("narrows 'key' in obj to objects with that property", () => {
+    const env = createEnvironment();
+    const objWithFoo = T.object({ foo: T.string });
+    const objWithBar = T.object({ bar: T.number });
+    env.bind("obj", T.union(objWithFoo, objWithBar));
+    const expr = getTestExpr('"foo" in obj');
+    const [trueEnv, falseEnv] = narrow(expr, env);
+    expect(typeValueToString(trueEnv.lookup("obj"))).toBe("{ foo: string }");
+    expect(typeValueToString(falseEnv.lookup("obj"))).toBe("{ bar: number }");
+  });
+
+  it("returns unchanged env when right side is not a union", () => {
+    const env = createEnvironment();
+    env.bind("obj", T.object({ foo: T.string }));
+    const expr = getTestExpr('"foo" in obj');
+    const [trueEnv, falseEnv] = narrow(expr, env);
+    expect(typeValueToString(trueEnv.lookup("obj"))).toBe("{ foo: string }");
+    expect(typeValueToString(falseEnv.lookup("obj"))).toBe("{ foo: string }");
+  });
+
+  it("evaluates Symbol.iterator in iterable receiver to true", () => {
+    const env = createEnvironment();
+    evaluateProgram(parse("const r = (Symbol.iterator in [1, 2]);").program, env);
+    expect(typeValueToString(env.lookup("r"))).toBe("true");
+  });
+
+  it("evaluates Symbol.iterator in plain object to false", () => {
+    const env = createEnvironment();
+    evaluateProgram(parse("const o = { a: 1 }; const r = (Symbol.iterator in o);").program, env);
+    expect(typeValueToString(env.lookup("r"))).toBe("false");
+  });
+
+  it("distributes Symbol.iterator in over unions", () => {
+    const env = createEnvironment();
+    evaluateProgram(
+      parse("const flag = JSON.parse('x'); const x = flag ? [1] : 5; const r = (Symbol.iterator in x);").program,
+      env,
+    );
+    expect(typeValueToString(env.lookup("x"))).toBe("[1] | 5");
+    expect(typeValueToString(env.lookup("r"))).toBe("true | false");
+  });
+});

package/src/__tests__/narrowing-switch.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import { T, typeValueEquals, typeValueToString, createEnvironment } from "@nudojs/core";
+import { parse } from "@nudojs/parser";
+import { evaluateFunction } from "../evaluator.ts";
+
+function getFunctionNode(source: string, name: string) {
+  const ast = parse(source);
+  const stmt = ast.program.body[0];
+  if (stmt.type === "FunctionDeclaration" && stmt.id?.name === name) return stmt;
+  throw new Error(`Function ${name} not found`);
+}
+
+describe("switch narrowing", () => {
+  it("narrows discriminated union in switch cases", () => {
+    const circle = T.object({ kind: T.literal("circle"), radius: T.number });
+    const rect = T.object({ kind: T.literal("rect"), w: T.number, h: T.number });
+    const shapeUnion = T.union(circle, rect);
+
+    const source = `
+function getArea(shape) {
+  switch (shape.kind) {
+    case "circle": return shape.radius;
+    case "rect": return shape.w;
+  }
+}
+`;
+
+    const fnNode = getFunctionNode(source, "getArea");
+    const env = createEnvironment();
+    const result = evaluateFunction(fnNode, [shapeUnion], env);
+
+    // shape.radius (circle) and shape.w (rect) are both number
+    expect(typeValueEquals(result, T.number)).toBe(true);
+  });
+
+  it("narrows typeof in switch", () => {
+    const source = `
+function describe(x) {
+  switch (typeof x) {
+    case "string": return x.toUpperCase();
+    case "number": return x + 1;
+    default: return x;
+  }
+}
+`;
+
+    const fnNode = getFunctionNode(source, "describe");
+    const env = createEnvironment();
+    const result = evaluateFunction(fnNode, [T.union(T.string, T.number)], env);
+
+    // string.toUpperCase() => string, number + 1 => number, default => string | number
+    // All branches return string | number
+    const expected = T.union(T.string, T.number);
+    expect(typeValueEquals(result, expected)).toBe(true);
+  });
+});

package/src/__tests__/narrowing-truthiness.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { T, typeValueEquals, typeValueToString, createEnvironment } from "@nudojs/core";
+import { parse } from "@nudojs/parser";
+import { narrow } from "../narrowing.ts";
+import type { ExpressionStatement } from "@babel/types";
+
+function getTestExpr(source: string) {
+  const ast = parse(source);
+  const stmt = ast.program.body[0] as ExpressionStatement;
+  return stmt.expression;
+}
+
+describe("narrow: truthiness", () => {
+  it("narrows if(x) to exclude null and undefined", () => {
+    const env = createEnvironment();
+    env.bind("x", T.union(T.string, T.null, T.undefined));
+    const expr = getTestExpr("x");
+    const [trueEnv, falseEnv] = narrow(expr, env);
+    expect(typeValueEquals(trueEnv.lookup("x"), T.string)).toBe(true);
+    const falseType = falseEnv.lookup("x");
+    expect(typeValueToString(falseType)).toBe("null | undefined");
+  });
+
+  it("narrows if(x) to exclude 0, empty string, false", () => {
+    const env = createEnvironment();
+    env.bind("x", T.union(T.number, T.string, T.boolean, T.null));
+    const expr = getTestExpr("x");
+    const [trueEnv, falseEnv] = narrow(expr, env);
+    const trueType = trueEnv.lookup("x");
+    expect(typeValueToString(trueType)).toBe("number | string | boolean");
+  });
+
+  it("does not narrow non-union types", () => {
+    const env = createEnvironment();
+    env.bind("x", T.string);
+    const expr = getTestExpr("x");
+    const [trueEnv, falseEnv] = narrow(expr, env);
+    expect(typeValueEquals(trueEnv.lookup("x"), T.string)).toBe(true);
+    expect(typeValueEquals(falseEnv.lookup("x"), T.string)).toBe(true);
+  });
+});
+
+describe("narrow: Array.isArray", () => {
+  it("narrows Array.isArray(x) to array type", () => {
+    const env = createEnvironment();
+    env.bind("x", T.union(T.array(T.string), T.object({ foo: T.number })));
+    const expr = getTestExpr("Array.isArray(x)");
+    const [trueEnv, falseEnv] = narrow(expr, env);
+    expect(trueEnv.lookup("x").kind).toBe("array");
+    expect(falseEnv.lookup("x").kind).toBe("object");
+  });
+});