tape-six 1.7.13 → 1.8.0

package/llms.txt

@@ -139,6 +139,37 @@ test('suite', async t => {
 test.beforeAll(() => { /* ... */ });
 ```
 
+## Subpath modules
+
+### tape-six/server — HTTP server harness
+
+Helpers for tests that need an ephemeral `node:http` server. Cross-runtime (Node, Bun, Deno; not for browser-side tests).
+
+```js
+import {withServer, startServer, setupServer} from 'tape-six/server';
+```
+
+- `withServer(serverHandler, clientHandler, opts?)` — scoped resource: spin up a server, run the test body with the base URL, tear down in `finally`. The 95% case.
+- `startServer(server, opts?)` — procedural primitive: returns `{server, base, port, host, close}`. For multi-phase tests or non-test code (e.g., `bin/tape6-server`) that wants long-term control. Races `'listening'` against `'error'` so port-busy rejects instead of hanging.
+- `setupServer(serverHandler, opts?)` — registers `beforeAll`/`afterAll` and returns a live-getter context for suite-shared servers. Don't destructure the returned object at module load — properties read live state on each access.
+- Options: `{host = '127.0.0.1', port = 0}`. Default host is explicit IPv4.
+
+`serverHandler` is the per-request callback (Node calls it once per incoming request). `clientHandler` is the per-scope test body (called once with the base URL). Either side may be the SUT.
+
+### tape-six/response — HTTP response helpers
+
+Reading helpers that work uniformly with both `Response` (fetch results) and `http.IncomingMessage` (Node low-level requests).
+
+```js
+import {asText, asJson, asBytes, header, headers} from 'tape-six/response';
+```
+
+- `asText(res)` — body as UTF-8 string.
+- `asJson(res)` — body parsed as JSON.
+- `asBytes(res)` — body as `Uint8Array`.
+- `header(res, name)` — single header value, case-insensitive. Returns `null` if absent.
+- `headers(res)` — all headers as a plain object with lowercase keys.
+
 ## Common patterns
 
 ### Basic test file
@@ -213,6 +244,41 @@ describe('my module', () => {
 });
 ```
 
+### Testing HTTP code with `withServer`
+
+```js
+import test from 'tape-six';
+import {withServer} from 'tape-six/server';
+import {asJson} from 'tape-six/response';
+
+test('GET /users returns the list', t =>
+  withServer(myHandler, async base => {
+    const res = await fetch(`${base}/users`);
+    t.equal(res.status, 200);
+    const body = await asJson(res);
+    t.equal(body.length, 3);
+  }));
+```
+
+Suite-shared server (multiple tests against one instance):
+
+```js
+import test, {beforeEach} from 'tape-six';
+import {setupServer} from 'tape-six/server';
+
+const server = setupServer((req, res) => {
+  recorded.push({method: req.method, url: req.url});
+  res.writeHead(204).end();
+});
+let recorded;
+beforeEach(() => { recorded = []; });
+
+test('records one request', async t => {
+  await fetch(`${server.base}/foo`);
+  t.equal(recorded.length, 1);
+});
+```
+
 ### Skip and TODO
 
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tape-six",
-  "version": "1.7.13",
+  "version": "1.8.0",
   "description": "TAP-inspired unit test library for Node, Deno, Bun, and browsers. ES modules, TypeScript, zero dependencies.",
   "type": "module",
   "main": "index.js",
@@ -8,6 +8,14 @@
   "types": "index.d.ts",
   "exports": {
     ".": "./index.js",
+    "./server": {
+      "types": "./src/server.d.ts",
+      "default": "./src/server.js"
+    },
+    "./response": {
+      "types": "./src/response.d.ts",
+      "default": "./src/response.js"
+    },
     "./bin/*": "./bin/*",
     "./*": "./src/*"
   },
@@ -87,7 +95,8 @@
       "/tests/test-*.mjs"
     ],
     "cli": [
-      "/tests/test-*.cjs"
+      "/tests/test-*.cjs",
+      "/tests/cli/test-*.js"
     ],
     "browser": [
       "/tests/browser/test-*.html"
@@ -102,8 +111,8 @@
   },
   "devDependencies": {
     "@types/chai": "^5.2.3",
-    "@types/node": "^25.5.0",
+    "@types/node": "^25.6.0",
     "chai": "^6.2.2",
-    "typescript": "^6.0.2"
+    "typescript": "^6.0.3"
   }
 }

package/skills/write-tests/SKILL.md

@@ -12,29 +12,76 @@ Write or update tests using the tape-six testing library.
 - `tape-six` supports ES modules (`.js`, `.mjs`, `.ts`, `.mts`) and CommonJS (`.cjs`, `.cts`).
 - TypeScript is supported natively — no transpilation needed (Node 22+, Deno, Bun run `.ts` files directly).
 - The default `tape6` runner uses worker threads for parallel execution. `tape6-seq` runs sequentially in-process — useful for debugging or when tests share state.
+- `tape-six` catches `AssertionError` automatically, so you can use Chai or `node:assert` inside tape-six tests if a project already uses them.
 
 ## Steps
 
-1. Read the testing guide at `node_modules/tape-six/TESTING.md` for API reference and patterns.
+1. Read the testing guide at `node_modules/tape-six/TESTING.md` for the full API reference and patterns.
 2. Identify the module or feature to test. Read its source code to understand the public API.
 3. Create or update the test file in `tests/test-<name>.js` (or `.ts` for TypeScript, `.cjs` for CommonJS):
    - **ESM** (`.js`): `import test from 'tape-six'` and import the module under test using the project's package name.
    - **CJS** (`.cjs`): `const {test} = require('tape-six')` and `const {...} = require('my-package')`. Always use `require()` — it is the correct CJS pattern. **Do NOT use `await import()` unless you have confirmed** (e.g., grep for `^await` at the top level) that the module under test uses top-level `await`, which is rare.
    - Write one top-level `test()` per logical group.
-   - Use embedded `await t.test()` for sub-cases.
-   - Use `t.beforeEach`/`t.afterEach` for shared setup/teardown.
+   - Use embedded `await t.test()` for sub-cases. **Always `await` embedded tests** to preserve execution order.
+   - Use `t.beforeEach`/`t.afterEach` for shared setup/teardown; `t.beforeAll`/`t.afterAll` (aliases `t.before`/`t.after`) for one-shot fixtures.
    - Cover: normal operation, edge cases, error conditions.
-   - Use `t.equal` for primitives, `t.deepEqual` for objects/arrays, `t.throws` for errors, `await t.rejects` for async errors.
    - All `msg` arguments are optional but recommended for clarity.
-4. **Browser-specific tests** — if the project uses browser testing with `tape6-server`. See the "Browser testing" section in `TESTING.md` for full details.
-   - Browsers run `.js` and `.mjs` only — no TypeScript, no CommonJS.
-   - Browsers can also run `.html` shim files (with inline importmap and `<script type="module">`).
-   - Place browser-only files in a subdirectory (e.g., `tests/browser/`) and add patterns to `"browser"` in the `tape6` config.
-   - Run: `npx tape6-server --trace`, then open `http://localhost:3000`.
-5. **Environment-specific tests** — the `tape6` config in `package.json` supports per-environment patterns (`tests`, `cli`, `node`, `bun`, `deno`, `browser`). All are additive. See "Configuring test discovery" in `TESTING.md`.
-6. **Verify (CLI):** run the new test file directly: `node tests/test-<name>.js`
-   - Run the full suite to check for regressions: `npm test`
-   - If debugging, use `npm run test:seq` (runs sequentially, easier to trace issues).
-   - To see which files are being run, add `--flags fo` (overrides the default `--flags FO`).
-7. **Verify (browser):** start `npx tape6-server --trace`, then open `http://localhost:3000/?q=/tests/test-<name>.js` to run a specific file. Use multiple `?q=` parameters to run several files. Open `http://localhost:3000/` to run all configured tests.
-8. Report results and any failures.
+4. **Pick the right assertion:**
+   - Primitives: `t.equal(a, b)` (strict). Use `t.deepEqual(a, b)` for objects/arrays.
+   - Truthiness: `t.ok(value)`, `t.notOk(value)`.
+   - Errors: `t.error(err)` asserts `err` is falsy (callback-style "no error").
+   - Sync throws: `t.throws(fn)`, `t.doesNotThrow(fn)`.
+   - Async: `await t.rejects(promise)`, `await t.resolves(promise)`.
+   - Strings: `t.matchString(str, /re/)`, `t.doesNotMatchString(str, /re/)`.
+   - Structural: `t.match(actual, pattern)` / `t.doesNotMatch(actual, pattern)` for partial object matching (uses deep6 `match()`).
+5. **Match error/value shape** (`throws` / `rejects` / `resolves` accept an optional matcher as the second arg):
+   ```js
+   t.throws(() => parse(''), TypeError); // Error subclass
+   t.throws(() => parse(''), /unexpected end/); // RegExp on error.message
+   t.throws(
+     () => parse(''),
+     e => e.code === 'EPARSE'
+   ); // predicate
+   t.throws(() => parse(''), {code: 'EPARSE'}); // deep6 object pattern
+   await t.rejects(fetchData(), /404/);
+   await t.resolves(fetchData(), {status: 200}); // matches resolved value
+   ```
+   A string second arg is still treated as the message for backward compatibility.
+6. **Wildcards in deep equality** — use `t.any` (alias `t._`) inside expected values to skip non-deterministic fields:
+   ```js
+   t.deepEqual(result, {id: t.any, name: 'Alice', createdAt: t.any});
+   ```
+7. **Async cancellation** — `t.signal` is an `AbortSignal` that fires when the test ends, times out, or is stopped. Pass it to long-running async work so it cancels cleanly:
+   ```js
+   test('aborts on test end', async t => {
+     const res = await fetch(url, {signal: t.signal});
+     t.equal(res.status, 200);
+   });
+   ```
+8. **Test options** — `test(name, options, fn)` accepts `{timeout, skip, todo, before, after, beforeAll, afterAll, beforeEach, afterEach}`. Use `timeout` (ms) for tests with bounded async work; the test fails and `t.signal` fires when exceeded.
+9. **Misc:**
+   - `test.skip(name, fn)` / `test.todo(name, fn)` — `skip` doesn't run; `todo` runs but failures don't fail the suite.
+   - `t.comment(msg)` — emit a TAP comment line.
+   - `t.skipTest(msg)` — skip the _current_ test from inside it.
+   - `t.bailOut(msg)` — stop the entire run (catastrophic).
+   - `t.OK(expr, msg)` (aliases `t.TRUE`, `t.ASSERT`) — returns a code string for `eval()` that asserts an expression and dumps top-level variables on failure. Useful for compact arithmetic/state checks: `eval(t.OK('a + b === 3'))`. Do not use in CSP-restricted contexts.
+10. **Testing HTTP code** — for tests that need an ephemeral HTTP server or want to read responses uniformly:
+    - **`tape-six/server`** (`withServer` / `startServer` / `setupServer`) — wraps the `node:http` lifecycle. `withServer(serverHandler, clientHandler, opts?)` is the per-test scoped resource: starts a server, runs the test body with the bound base URL, tears down in `finally`. `setupServer(serverHandler, opts?)` registers `beforeAll`/`afterAll` and returns a live-getter handle for suite-shared servers (don't destructure at module load — properties read live state). `startServer(server, opts?)` is the procedural primitive for multi-phase tests. Default host is `'127.0.0.1'`. Cross-runtime (Node, Bun, Deno).
+    - **`tape-six/response`** (`asText` / `asJson` / `asBytes` / `header` / `headers`) — reading helpers that work uniformly on both W3C `Response` (fetch results) and Node `http.IncomingMessage`.
+    - Per-test mock-server state reset (e.g., clearing a `recorded[]` array) stays user-side: compose your own `beforeEach`. `setupServer` owns the server lifecycle; you own state.
+    - **Placement:** these tests can't run in the browser worker — `node:http` doesn't exist there. Don't drop them into a folder matched by the universal `tape6.tests` glob; put them in a CLI-only path (e.g. `tests/cli/test-*.js`) and ensure the matching glob is in `tape6.cli` instead.
+    - See "Testing HTTP code" in `TESTING.md` for examples.
+11. **Browser-specific tests** — if the project uses browser testing with `tape6-server`. See "Browser testing" in `TESTING.md`.
+    - Browsers run `.js` and `.mjs` only — no TypeScript, no CommonJS.
+    - Browsers can also run `.html` shim files (with inline importmap and `<script type="module">`).
+    - Place browser-only files in `tests/browser/` and add patterns to `"browser"` in the `tape6` config.
+    - Run: `npx tape6-server --trace`, then open `http://localhost:3000`. Use `?q=<glob>` to filter, `?flags=FO` and `?par=N` to control output and parallelism.
+12. **Environment-specific tests** — the `tape6` config in `package.json` supports per-env patterns (`tests`, `cli`, `node`, `bun`, `deno`, `browser`). All are additive. See "Configuring test discovery" in `TESTING.md`.
+13. **Verify (CLI):** run the new test file directly: `node tests/test-<name>.js`
+    - Run the full suite to check for regressions: `npm test`
+    - For debugging, use `npm run test:seq` (sequential, in-process).
+    - To see which files are being run, add `--flags fo` (overrides the default `--flags FO`).
+    - To inspect the resolved config without running, use `npx tape6 --info`.
+    - For tests with heavy `beforeAll` (Docker spawn, big fixture loads), bump the worker startup timer with `TAPE6_WORKER_START_TIMEOUT=60000`. The default is 5 s.
+14. **Verify (browser):** start `npx tape6-server --trace`, then open `http://localhost:3000/?q=/tests/test-<name>.js` to run a specific file. Use multiple `?q=` parameters to run several files. Open `http://localhost:3000/` to run all configured tests.
+15. Report results and any failures.

package/src/State.js

@@ -186,29 +186,34 @@ export class State {
       typeof event.diffTime !== 'number' && (event.diffTime = event.time - this.startTime);
     }
 
-    if (
-      event.type === 'assert' &&
-      (event.operator === 'error' || event.operator === 'exception') &&
-      typeof event.data?.actual?.stack == 'string'
-    ) {
-      event.stackList = getStackList(event.data.actual);
-      event.at = event.stackList[0];
-    }
+    // Stack walking is only needed when the event will be reported as a failure.
+    // Reporters (TapReporter, TTYReporter) only read event.at / event.stackList
+    // inside `if (event.fail)` blocks, so for passing assertions this is wasted work.
+    if (isFailed) {
+      if (
+        event.type === 'assert' &&
+        (event.operator === 'error' || event.operator === 'exception') &&
+        typeof event.data?.actual?.stack == 'string'
+      ) {
+        event.stackList = getStackList(event.data.actual);
+        event.at = event.stackList[0];
+      }
 
-    if (event.type === 'assertion-error' && typeof event.data?.error?.stack == 'string') {
-      event.stackList = getStackList(event.data.error);
-      event.at = event.stackList[0];
-    }
+      if (event.type === 'assertion-error' && typeof event.data?.error?.stack == 'string') {
+        event.stackList = getStackList(event.data.error);
+        event.at = event.stackList[0];
+      }
 
-    if (!event.at && typeof event.marker?.stack == 'string') {
-      event.stackList = getStackList(event.marker);
-      event.at =
-        event.stackList[
-          Math.min(
-            typeof event.markerIndex == 'number' ? event.markerIndex : 1,
-            event.stackList.length
-          )
-        ];
+      if (!event.at && typeof event.marker?.stack == 'string') {
+        event.stackList = getStackList(event.marker);
+        event.at =
+          event.stackList[
+            Math.min(
+              typeof event.markerIndex == 'number' ? event.markerIndex : 1,
+              event.stackList.length
+            )
+          ];
+      }
     }
 
     if ((event.type === 'assert' || event.type === 'assertion-error') && event.data) {

package/src/Tester.js

@@ -1,13 +1,30 @@
 import {equal, match, any} from './deep6/index.js';
 import {getTimer} from './utils/timer.js';
 
-const throwHelper = fn => {
+const tryFn = fn => {
   try {
     fn();
+    return {threw: false};
   } catch (error) {
-    return error;
+    return {threw: true, error};
   }
-  return null;
+};
+
+const isErrorClass = fn =>
+  fn === Error || (typeof fn === 'function' && fn.prototype instanceof Error);
+
+const applyMatcher = (actual, matcher) => {
+  if (matcher === undefined) return true;
+  if (typeof matcher === 'function') {
+    if (isErrorClass(matcher)) return actual instanceof matcher;
+    return !!matcher(actual);
+  }
+  if (matcher instanceof RegExp) {
+    const str = actual instanceof Error ? actual.message : String(actual);
+    return matcher.test(str);
+  }
+  if (matcher !== null && typeof matcher === 'object') return match(actual, matcher);
+  return actual === matcher;
 };
 
 export class Tester {
@@ -264,36 +281,41 @@ export class Tester {
     });
   }
 
-  throws(fn, msg) {
+  throws(fn, matcher, msg) {
     if (typeof fn != 'function') throw new TypeError('the first argument should be a function');
-    const result = throwHelper(fn);
+    if (typeof matcher === 'string' && msg === undefined) {
+      msg = matcher;
+      matcher = undefined;
+    }
+    const {threw, error} = tryFn(fn);
+    const matched = threw && applyMatcher(error, matcher);
     this.reporter.report({
       name: msg || 'should throw',
       test: this.testNumber,
       marker: new Error(),
       time: this.timer.now(),
       operator: 'throws',
-      fail: !result,
+      fail: !matched,
       data: {
-        expected: null,
-        actual: result
+        expected: matcher === undefined ? null : matcher,
+        actual: threw ? error : null
       }
     });
   }
 
   doesNotThrow(fn, msg) {
     if (typeof fn != 'function') throw new TypeError('the first argument should be a function');
-    const result = throwHelper(fn);
+    const {threw, error} = tryFn(fn);
     this.reporter.report({
       name: msg || 'should not throw',
       test: this.testNumber,
       marker: new Error(),
       time: this.timer.now(),
       operator: 'doesNotThrow',
-      fail: !!result,
+      fail: threw,
       data: {
         expected: null,
-        actual: result
+        actual: threw ? error : null
       }
     });
   }
@@ -325,7 +347,7 @@ export class Tester {
       test: this.testNumber,
       marker: new Error(),
       time: this.timer.now(),
-      operator: 'doesNotMatch',
+      operator: 'doesNotMatchString',
       fail: regexp.test(string),
       data: {
         expected: regexp,
@@ -355,7 +377,7 @@ export class Tester {
       test: this.testNumber,
       marker: new Error(),
       time: this.timer.now(),
-      operator: 'doesNotMatchObject',
+      operator: 'doesNotMatch',
       fail: match(a, b),
       data: {
         expected: b,
@@ -364,49 +386,59 @@ export class Tester {
     });
   }
 
-  rejects(promise, msg) {
+  rejects(promise, matcher, msg) {
     if (!promise || typeof promise.then != 'function')
       throw new TypeError('the first argument should be a promise');
+    if (typeof matcher === 'string' && msg === undefined) {
+      msg = matcher;
+      matcher = undefined;
+    }
     return promise
       .then(
-        () => null,
-        error => error
+        () => ({resolved: true}),
+        error => ({resolved: false, error})
       )
-      .then(result => {
+      .then(({resolved, error}) => {
+        const matched = !resolved && applyMatcher(error, matcher);
         this.reporter.report({
           name: msg || 'should be rejected',
           test: this.testNumber,
           marker: new Error(),
           time: this.timer.now(),
           operator: 'rejects',
-          fail: !result,
+          fail: !matched,
           data: {
-            expected: null,
-            actual: result
+            expected: matcher === undefined ? null : matcher,
+            actual: resolved ? null : error
           }
         });
       });
   }
 
-  resolves(promise, msg) {
+  resolves(promise, matcher, msg) {
     if (!promise || typeof promise.then != 'function')
       throw new TypeError('the first argument should be a promise');
+    if (typeof matcher === 'string' && msg === undefined) {
+      msg = matcher;
+      matcher = undefined;
+    }
     return promise
       .then(
-        () => null,
-        error => error
+        value => ({resolved: true, value}),
+        error => ({resolved: false, error})
       )
-      .then(result => {
+      .then(({resolved, value, error}) => {
+        const matched = resolved && applyMatcher(value, matcher);
         this.reporter.report({
           name: msg || 'should not be rejected',
           test: this.testNumber,
           marker: new Error(),
           time: this.timer.now(),
           operator: 'resolves',
-          fail: !!result,
+          fail: !matched,
           data: {
-            expected: null,
-            actual: result
+            expected: matcher === undefined ? null : matcher,
+            actual: resolved ? (matcher === undefined ? null : value) : error
           }
         });
       });

package/src/deep6/env.d.ts

@@ -0,0 +1,174 @@
+// Type definitions for deep6 environment
+// Generated from src/env.js
+
+/**
+ * Unification environment managing variable bindings and stack frames
+ *
+ * Maintains two parallel prototype-chain structures:
+ * - `variables`: maps variable names to their alias groups
+ * - `values`: maps variable names/aliases to their bound values
+ *
+ * Stack frames enable scoped bindings that can be reverted.
+ */
+export declare class Env {
+  /** Map of variable names to their alias groups */
+  variables: Record<string | symbol, unknown>;
+  /** Map of variable names/aliases to their bound values */
+  values: Record<string | symbol, unknown>;
+  /** Current stack frame depth */
+  depth: number;
+
+  constructor();
+
+  /** Pushes a new stack frame for nested scoping */
+  push(): void;
+
+  /**
+   * Pops the current stack frame, reverting bindings
+   * @throws {Error} If stack is empty
+   */
+  pop(): void;
+
+  /**
+   * Reverts to a specific stack frame depth
+   * @param depth - Target depth to revert to
+   * @throws {Error} If depth is higher than current depth
+   */
+  revert(depth: number): void;
+
+  /**
+   * Creates an alias between two variable names
+   * @param name1 - First variable name
+   * @param name2 - Second variable name
+   */
+  bindVar(name1: string | symbol, name2: string | symbol): void;
+
+  /**
+   * Binds a variable name (and its aliases) to a value
+   * @param name - Variable name to bind
+   * @param val - Value to bind
+   */
+  bindVal(name: string | symbol, val: unknown): void;
+
+  /**
+   * Checks if a variable is bound to a value
+   * @param name - Variable name to check
+   * @returns True if variable has a bound value
+   */
+  isBound(name: string | symbol): boolean;
+
+  /**
+   * Checks if two variable names are aliases
+   * @param name1 - First variable name
+   * @param name2 - Second variable name
+   * @returns True if variables are aliases
+   */
+  isAlias(name1: string | symbol, name2: string | symbol): boolean;
+
+  /**
+   * Gets the value bound to a variable
+   * @param name - Variable name
+   * @returns The bound value, or undefined if unbound
+   */
+  get(name: string | symbol): unknown;
+
+  /**
+   * Returns all variable bindings (for debugging)
+   * @returns Array of name/value pairs
+   */
+  getAllValues(): Array<{name: string | symbol; value: unknown}>;
+}
+
+/**
+ * Base class for custom unification behavior
+ *
+ * Subclasses must implement the `unify` method.
+ */
+export declare class Unifier {
+  /**
+   * Unifies this unifier with a value
+   * @param val - Value to unify with
+   * @param ls - Left argument stack
+   * @param rs - Right argument stack
+   * @param env - Unification environment
+   * @returns True if unification succeeds
+   */
+  unify(val: unknown, ls: unknown[], rs: unknown[], env: Env): boolean;
+}
+
+/**
+ * Type guard for Unifier instances
+ * @param x - Value to check
+ * @returns True if x is a Unifier
+ */
+export declare const isUnifier: (x: unknown) => x is Unifier;
+
+/**
+ * Wildcard symbol that matches any value during unification
+ */
+export declare const any: unique symbol;
+
+/** Alias for `any` */
+export declare const _: typeof any;
+
+/**
+ * Logical variable for capturing values during unification
+ *
+ * Variables can be bound to values, aliased to other variables,
+ * and dereferenced through an Env.
+ */
+export declare class Variable extends Unifier {
+  /** Variable identifier */
+  name: string | symbol;
+
+  /**
+   * @param name - Optional identifier (defaults to a unique Symbol)
+   */
+  constructor(name?: string | symbol);
+
+  /**
+   * Checks if this variable is bound in the given environment
+   * @param env - Unification environment
+   * @returns True if bound
+   */
+  isBound(env: Env): boolean;
+
+  /**
+   * Checks if this variable is aliased to another
+   * @param name - Variable name, symbol, or Variable instance
+   * @param env - Unification environment
+   * @returns True if aliased
+   */
+  isAlias(name: Variable | string | symbol, env: Env): boolean;
+
+  /**
+   * Gets the bound value of this variable
+   * @param env - Unification environment
+   * @returns The bound value, or undefined if unbound
+   */
+  get(env: Env): unknown;
+
+  /**
+   * Unifies this variable with a value
+   * @param val - Value to unify with
+   * @param ls - Left argument stack
+   * @param rs - Right argument stack
+   * @param env - Unification environment
+   * @returns True if unification succeeds
+   */
+  unify(val: unknown, ls: unknown[], rs: unknown[], env: Env): boolean;
+}
+
+/**
+ * Type guard for Variable instances
+ * @param x - Value to check
+ * @returns True if x is a Variable
+ */
+export declare const isVariable: (x: unknown) => x is Variable;
+
+/**
+ * Creates a new Variable
+ * @param name - Optional identifier (defaults to a unique Symbol)
+ * @returns A new Variable instance
+ */
+export declare const variable: (name?: string | symbol) => Variable;

package/src/deep6/env.js

@@ -13,7 +13,7 @@ const collectSymbols = object => {
 };
 
 const ensure = (object, depth) => {
-  while (object[keyDepth] > depth) object = object.getPrototypeOf(object);
+  while (object[keyDepth] > depth) object = Object.getPrototypeOf(object);
   if (object[keyDepth] < depth) {
     object = Object.create(object);
     object[keyDepth] = depth;
@@ -90,14 +90,14 @@ class Env {
   }
   // helpers
   isBound(name) {
-    return name in env.values;
+    return name in this.values;
   }
   isAlias(name1, name2) {
-    const u = env.variables[name2];
+    const u = this.variables[name2];
     return u && u[name1] === 1;
   }
   get(name) {
-    return env.values[name];
+    return this.values[name];
   }
   // debugging
   getAllValues() {