tape-six 1.7.13 → 1.8.0

package/src/deep6/unify.js

@@ -24,18 +24,17 @@ class Wrap extends Unifier {
       value = isWrapped ? val.object : val;
     if (!value || typeof value != 'object' || Array.isArray(this.object) !== Array.isArray(value)) return false;
     if (Array.isArray(this.object)) {
-      if (!Array.isArray(value)) return false;
       return isWrapped
         ? unifyObjects(this.object, this.type, this, val.object, val.type, val, ls, rs, env)
         : unifyObjects(this.object, this.type, this, val, env.openArrays ? 'open' : 'exact', null, ls, rs, env);
     }
-    if (typeof Map == 'function' && this.object instanceof Map) {
+    if (this.object instanceof Map) {
       if (!(value instanceof Map)) return false;
       return isWrapped
         ? unifyMaps(this.object, this.type, this, val.object, val.type, val, ls, rs, env)
         : unifyMaps(this.object, this.type, this, val, env.openMaps ? 'open' : 'exact', null, ls, rs, env);
     }
-    if (typeof Set == 'function' && this.object instanceof Set) {
+    if (this.object instanceof Set) {
       if (!(value instanceof Set)) return false;
       return isWrapped
         ? unifySets(this.object, this.type, this, val.object, val.type, val, ls, rs, env)
@@ -61,11 +60,12 @@ const registry = [
     Date,
     (l, r) => l instanceof Date && r instanceof Date && l.getTime() == r.getTime(),
     RegExp,
-    (l, r) =>
-      l instanceof RegExp && r instanceof RegExp && l.source == r.source && l.global == r.global && l.multiline == r.multiline && l.ignoreCase == r.ignoreCase
+    (l, r) => l instanceof RegExp && r instanceof RegExp && l.source == r.source && l.flags == r.flags
   ],
   filters = [];
 
+typeof URL == 'function' && registry.push(URL, (l, r) => l instanceof URL && r instanceof URL && l.href == r.href);
+
 // possible well-known constructors
 
 const unifyTypedArrays = Type => (l, r, ls, rs, env) => {
@@ -99,9 +99,10 @@ const unifyDataView = (l, r, ls, rs, env) => {
 };
 typeof DataView == 'function' && registry.push(DataView, unifyDataView);
 
+const unifyUint8Array = unifyTypedArrays(Uint8Array);
 const unifyArrayBuffer = (l, r, ls, rs, env) => {
   if (!(l instanceof ArrayBuffer) || !(r instanceof ArrayBuffer) || l.byteLength != r.byteLength) return false;
-  return unifyTypedArrays(Uint8Array)(new Uint8Array(l), new Uint8Array(r), ls, rs, env);
+  return unifyUint8Array(new Uint8Array(l), new Uint8Array(r), ls, rs, env);
 };
 typeof ArrayBuffer == 'function' && typeof Uint8Array == 'function' && registry.push(ArrayBuffer, unifyArrayBuffer);
 
@@ -161,22 +162,28 @@ const mapOps = {
     }
   }
 };
-mapOps.exact.exact.compare = mapOps.exact.open.compare = mapOps.exact.soft.compare = (l, r, ls, rs) => {
-  for (const [key, value] of r) {
-    if (!l.has(key)) return false;
-    ls.push(l.get(key));
-    rs.push(value);
-  }
-  return true;
-};
-mapOps.open.open.compare = mapOps.open.soft.compare = mapOps.soft.soft.compare = (l, r, ls, rs) => {
-  for (const [key, value] of r) {
-    if (!l.has(key)) continue;
-    ls.push(l.get(key));
-    rs.push(value);
-  }
-  return true;
-};
+mapOps.exact.exact.compare =
+  mapOps.exact.open.compare =
+  mapOps.exact.soft.compare =
+    (l, r, ls, rs) => {
+      for (const [key, value] of r) {
+        if (!l.has(key)) return false;
+        ls.push(l.get(key));
+        rs.push(value);
+      }
+      return true;
+    };
+mapOps.open.open.compare =
+  mapOps.open.soft.compare =
+  mapOps.soft.soft.compare =
+    (l, r, ls, rs) => {
+      for (const [key, value] of r) {
+        if (!l.has(key)) continue;
+        ls.push(l.get(key));
+        rs.push(value);
+      }
+      return true;
+    };
 mapOps.exact.soft.update = mapOps.open.soft.update = function () {
   for (const [key, value] of this.l) {
     !this.r.has(key) && this.r.set(key, value);
@@ -186,7 +193,19 @@ mapOps.exact.soft.update = mapOps.open.soft.update = function () {
 const unifyMaps = (l, lt, lm, r, rt, rm, ls, rs, env) => {
   const ols = ls;
   if (lt > rt) {
-    [l, lt, lm, ls, r, rt, rm, rs] = [r, rt, rm, rs, l, lt, lm, ls];
+    let tmp;
+    tmp = l;
+    l = r;
+    r = tmp;
+    tmp = lt;
+    lt = rt;
+    rt = tmp;
+    tmp = lm;
+    lm = rm;
+    rm = tmp;
+    tmp = ls;
+    ls = rs;
+    rs = tmp;
   }
   const ops = mapOps[lt][rt];
   if (ops.precheck && !ops.precheck(l, r)) return false;
@@ -231,8 +250,13 @@ const setOps = {
     }
   }
 };
-setOps.exact.exact.compare = setOps.exact.open.compare = setOps.exact.soft.compare = setOps.open.open.compare = setOps.open.soft.compare = setOps.soft.soft.compare = () =>
-  true;
+setOps.exact.exact.compare =
+  setOps.exact.open.compare =
+  setOps.exact.soft.compare =
+  setOps.open.open.compare =
+  setOps.open.soft.compare =
+  setOps.soft.soft.compare =
+    () => true;
 setOps.exact.soft.update = setOps.open.soft.update = function () {
   for (const key of this.l) {
     this.r.add(key);
@@ -242,7 +266,19 @@ setOps.exact.soft.update = setOps.open.soft.update = function () {
 const unifySets = (l, lt, lm, r, rt, rm, ls, rs, env) => {
   const ols = ls;
   if (lt > rt) {
-    [l, lt, lm, ls, r, rt, rm, rs] = [r, rt, rm, rs, l, lt, lm, ls];
+    let tmp;
+    tmp = l;
+    l = r;
+    r = tmp;
+    tmp = lt;
+    lt = rt;
+    rt = tmp;
+    tmp = lm;
+    lm = rm;
+    rm = tmp;
+    tmp = ls;
+    ls = rs;
+    rs = tmp;
   }
   const ops = setOps[lt][rt];
   if (ops.precheck && !ops.precheck(l, r)) return false;
@@ -267,7 +303,10 @@ const objectOps = {
           rKeys = rKeys.concat(Object.getOwnPropertySymbols(r));
         }
         if (lKeys.length != rKeys.length) return false;
-        return lKeys.every(k => hasOwnProperty.call(r, k));
+        for (let i = 0; i < lKeys.length; ++i) {
+          if (!hasOwnProperty.call(r, lKeys[i])) return false;
+        }
+        return true;
       }
     },
     open: {},
@@ -298,29 +337,34 @@ const objectOps = {
     }
   }
 };
-objectOps.exact.exact.compare = objectOps.exact.open.compare = objectOps.exact.soft.compare = (l, r, ls, rs, env) => {
-  let keys = Object.keys(r);
-  if (env.symbols) keys = keys.concat(Object.getOwnPropertySymbols(r));
-  return keys.every(k => {
-    if (hasOwnProperty.call(l, k)) {
-      ls.push(l[k]);
-      rs.push(r[k]);
+objectOps.exact.exact.compare =
+  objectOps.exact.open.compare =
+  objectOps.exact.soft.compare =
+    (l, r, ls, rs, env) => {
+      let keys = Object.keys(r);
+      if (env.symbols) keys = keys.concat(Object.getOwnPropertySymbols(r));
+      for (let i = 0; i < keys.length; ++i) {
+        const k = keys[i];
+        if (!hasOwnProperty.call(l, k)) return false;
+        ls.push(l[k]);
+        rs.push(r[k]);
+      }
       return true;
-    }
-    return false;
-  });
-};
-objectOps.open.open.compare = objectOps.open.soft.compare = objectOps.soft.soft.compare = (l, r, ls, rs, env) => {
-  let keys = Object.keys(r);
-  if (env.symbols) keys = keys.concat(Object.getOwnPropertySymbols(r));
-  for (const k of keys) {
-    if (hasOwnProperty.call(l, k)) {
-      ls.push(l[k]);
-      rs.push(r[k]);
-    }
-  }
-  return true;
-};
+    };
+objectOps.open.open.compare =
+  objectOps.open.soft.compare =
+  objectOps.soft.soft.compare =
+    (l, r, ls, rs, env) => {
+      let keys = Object.keys(r);
+      if (env.symbols) keys = keys.concat(Object.getOwnPropertySymbols(r));
+      for (const k of keys) {
+        if (hasOwnProperty.call(l, k)) {
+          ls.push(l[k]);
+          rs.push(r[k]);
+        }
+      }
+      return true;
+    };
 objectOps.exact.soft.update = objectOps.open.soft.update = function () {
   let keys = Object.keys(this.l);
   if (this.e.symbols) keys = keys.concat(Object.getOwnPropertySymbols(this.l));
@@ -332,7 +376,19 @@ objectOps.exact.soft.update = objectOps.open.soft.update = function () {
 const unifyObjects = (l, lt, lm, r, rt, rm, ls, rs, env) => {
   const ols = ls;
   if (lt > rt) {
-    [l, lt, lm, ls, r, rt, rm, rs] = [r, rt, rm, rs, l, lt, lm, ls];
+    let tmp;
+    tmp = l;
+    l = r;
+    r = tmp;
+    tmp = lt;
+    lt = rt;
+    rt = tmp;
+    tmp = lm;
+    lm = rm;
+    rm = tmp;
+    tmp = ls;
+    ls = rs;
+    rs = tmp;
   }
   const ops = objectOps[lt][rt];
   if (ops.precheck && !ops.precheck(l, r, env)) return false;
@@ -354,36 +410,39 @@ const unify = (l, r, env, options) => {
   env = Object.assign(env, options);
   // options: openObjects, openArrays, openMaps, openSets, circular, loose, ignoreFunctions, signedZero, symbols.
   const ls = [l],
-    rs = [r],
-    lSeen = new Map(),
+    rs = [r];
+  let lSeen, rSeen;
+  if (env.circular) {
+    lSeen = new Map();
     rSeen = new Map();
+  }
   main: while (ls.length) {
     // perform a command, or extract a pair
     l = ls.pop();
-    if (l instanceof Command) {
+    if (typeof l == 'object' && l instanceof Command) {
       l.f();
       continue;
     }
     r = rs.pop();
     // direct equality
     if (l === r) {
-      if (env.circular && l && typeof l == 'object' && lSeen.has(l) ^ rSeen.has(r)) return null;
+      if (lSeen && l && typeof l == 'object' && lSeen.has(l) ^ rSeen.has(r)) return null;
       if (env.signedZero && l === 0 && 1 / l !== 1 / r) return null;
       continue;
     }
     // anyvar
     if (l === _ || r === _) continue;
     // process variables (variables have priority)
-    if (l instanceof Variable) {
+    if (typeof l == 'object' && l instanceof Variable) {
       if (l.unify(r, ls, rs, env)) continue;
       return null;
     }
-    if (r instanceof Variable) {
+    if (typeof r == 'object' && r instanceof Variable) {
       if (r.unify(l, ls, rs, env)) continue;
       return null;
     }
     // process circular dependencies
-    if (env.circular) {
+    if (lSeen) {
       const lIndex = lSeen.get(l);
       if (typeof lIndex == 'number') {
         if (lIndex === rSeen.get(r)) continue main;
@@ -396,11 +455,11 @@ const unify = (l, r, env, options) => {
       r && typeof r == 'object' && rSeen.set(r, rSeen.size);
     }
     // invoke custom unifiers
-    if (l instanceof Unifier) {
+    if (typeof l == 'object' && l instanceof Unifier) {
       if (l.unify(r, ls, rs, env)) continue;
       return null;
     }
-    if (r instanceof Unifier) {
+    if (typeof r == 'object' && r instanceof Unifier) {
       if (r.unify(l, ls, rs, env)) continue;
       return null;
     }
@@ -414,12 +473,17 @@ const unify = (l, r, env, options) => {
     if (typeof l == 'number' && isNaN(l) && isNaN(r)) continue;
     // cut off impossible combinations
     if (typeof l != 'object' || !l || !r) return null;
-    // process registered constructors
-    const registry = unify.registry;
-    for (let i = 0; i < registry.length; i += 2) {
-      if (l instanceof registry[i] || r instanceof registry[i]) {
-        if (registry[i + 1](l, r, ls, rs, env)) continue main;
-        return null;
+    // fast path: plain objects and arrays skip registry
+    const lp = Object.getPrototypeOf(l),
+      rp = Object.getPrototypeOf(r);
+    if (!((lp === Object.prototype || lp === null || lp === Array.prototype) && (rp === Object.prototype || rp === null || rp === Array.prototype))) {
+      // process registered constructors
+      const registry = unify.registry;
+      for (let i = 0; i < registry.length; i += 2) {
+        if (l instanceof registry[i] || r instanceof registry[i]) {
+          if (registry[i + 1](l, r, ls, rs, env)) continue main;
+          return null;
+        }
       }
     }
     // process registered filters
@@ -442,5 +506,5 @@ const unify = (l, r, env, options) => {
 unify.registry = registry;
 unify.filters = filters;
 
-export {_, Env, Unifier, isUnifier, Variable, variable, isVariable, _ as any, open, soft, isOpen, isSoft, isWrapped};
+export {_, Env, Unifier, isUnifier, Variable, variable, isVariable, _ as any, open, soft, isOpen, isSoft, isWrapped, unify};
 export default unify;

package/src/deep6/utils/replaceVars.d.ts

@@ -0,0 +1,25 @@
+// Type definitions for deep6 replaceVars utility
+// Generated from src/utils/replaceVars.js
+
+import type {Env, Variable} from '../env.js';
+
+/**
+ * Creates a tagged template function that substitutes variables from an environment
+ *
+ * Template interpolations can be Variable instances (resolved via `.get(env)`),
+ * strings/numbers/symbols (looked up in `env.values`), or other values (coerced to string).
+ *
+ * @param env - Unification environment with variable bindings
+ * @returns A tagged template literal function
+ *
+ * @example
+ * ```ts
+ * const x = variable('x');
+ * const env = unify({a: x}, {a: 42});
+ * const t = replaceVars(env);
+ * t`The answer is ${x}!`; // "The answer is 42!"
+ * ```
+ */
+export declare const replaceVars: (env: Env) => (strings: TemplateStringsArray, ...vars: unknown[]) => string;
+
+export default replaceVars;

package/src/deep6/utils/replaceVars.js

@@ -1,24 +1,28 @@
 import {isVariable} from '../env.js';
 
-const replaceVars = env => (strings, ...vars) => {
-  let buffer = strings[0];
-  for(let i = 0; i < vars.length;) {
-    const v = vars[i];
-    if (isVariable(v)) {
-      buffer += v.get(env);
-    } else switch (typeof v) {
-      case 'string':
-      case 'number':
-      case 'symbol':
-        buffer += env.values[v];
-        break;
-      default:
-        buffer += v;
-        break;
+const replaceVars =
+  env =>
+  (strings, ...vars) => {
+    let buffer = strings[0];
+    for (let i = 0; i < vars.length; ) {
+      const v = vars[i];
+      if (isVariable(v)) {
+        buffer += v.get(env);
+      } else
+        switch (typeof v) {
+          case 'string':
+          case 'number':
+          case 'symbol':
+            buffer += env.values[v];
+            break;
+          default:
+            buffer += v;
+            break;
+        }
+      buffer += strings[++i];
     }
-    buffer += strings[++i];
-  }
-  return buffer;
-};
+    return buffer;
+  };
 
+export {replaceVars};
 export default replaceVars;

package/src/response.d.ts

@@ -0,0 +1,43 @@
+import type {IncomingMessage} from 'node:http';
+
+/**
+ * Anything `asText` / `asJson` / `asBytes` / `header` / `headers` accept.
+ * Either a W3C `Response` (from `fetch`) or a Node `http.IncomingMessage`.
+ */
+export type ResponseLike = Response | IncomingMessage;
+
+/**
+ * Read the response body as a UTF-8 string. Works with both `Response`
+ * (delegates to `res.text()`) and `http.IncomingMessage` (drains the
+ * stream and decodes).
+ */
+export function asText(res: ResponseLike): Promise<string>;
+
+/**
+ * Read the response body and parse as JSON. Equivalent to
+ * `JSON.parse(await asText(res))`; uses `res.json()` directly when
+ * available.
+ */
+export function asJson<T = unknown>(res: ResponseLike): Promise<T>;
+
+/**
+ * Read the response body as raw bytes (`Uint8Array`). For
+ * `http.IncomingMessage`, drains the stream; for `Response`, delegates
+ * to `arrayBuffer()`.
+ */
+export function asBytes(res: ResponseLike): Promise<Uint8Array>;
+
+/**
+ * Read a single response header by name (case-insensitive). Returns
+ * `null` if the header isn't present (matching `Response.headers.get`
+ * semantics). For `http.IncomingMessage` headers that are arrays
+ * (e.g. `set-cookie`), values are joined with `, `.
+ */
+export function header(res: ResponseLike, name: string): string | null;
+
+/**
+ * Return all response headers as a plain object with lowercase keys.
+ * Array-valued headers (e.g. `set-cookie` on `IncomingMessage`) are
+ * joined with `, ` to match `Response.headers` shape.
+ */
+export function headers(res: ResponseLike): Record<string, string>;

package/src/response.js

@@ -0,0 +1,57 @@
+// @ts-self-types="./response.d.ts"
+
+const isWebResponse = res =>
+  typeof res?.text === 'function' && typeof res?.headers?.get === 'function';
+
+const drainAsBuffer = res =>
+  new Promise((resolve, reject) => {
+    const chunks = [];
+    res.on('data', chunk => chunks.push(chunk));
+    res.on('end', () => {
+      try {
+        resolve(Buffer.concat(chunks));
+      } catch (error) {
+        reject(error);
+      }
+    });
+    res.on('error', reject);
+  });
+
+export const asText = async res => {
+  if (isWebResponse(res)) return await res.text();
+  const buffer = await drainAsBuffer(res);
+  return buffer.toString('utf8');
+};
+
+export const asJson = async res => {
+  if (isWebResponse(res)) return await res.json();
+  return JSON.parse(await asText(res));
+};
+
+export const asBytes = async res => {
+  if (isWebResponse(res)) {
+    const ab = await res.arrayBuffer();
+    return new Uint8Array(ab);
+  }
+  const buffer = await drainAsBuffer(res);
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+};
+
+export const header = (res, name) => {
+  if (isWebResponse(res)) return res.headers.get(name);
+  const value = res.headers?.[name.toLowerCase()];
+  return value === undefined ? null : Array.isArray(value) ? value.join(', ') : value;
+};
+
+export const headers = res => {
+  const out = {};
+  if (isWebResponse(res)) {
+    for (const [k, v] of res.headers) out[k.toLowerCase()] = v;
+    return out;
+  }
+  if (!res.headers) return out;
+  for (const [k, v] of Object.entries(res.headers)) {
+    out[k.toLowerCase()] = Array.isArray(v) ? v.join(', ') : v;
+  }
+  return out;
+};

package/src/server.d.ts

@@ -0,0 +1,81 @@
+import type {RequestListener, Server} from 'node:http';
+
+/**
+ * Result of starting a server. Properties reflect the actual bound address
+ * (e.g. `port` is the OS-assigned port when `0` was requested).
+ */
+export interface ServerLifecycle {
+  /** The underlying `http.Server` instance. */
+  server: Server;
+  /** Base URL of the bound server, e.g. `"http://127.0.0.1:54321"`. */
+  base: string;
+  /** Actual port the server is listening on. */
+  port: number;
+  /** Host the server is bound to. */
+  host: string;
+  /**
+   * Close the server. Idempotent. Calls `server.closeAllConnections()`
+   * (when available) so keep-alive sockets don't delay teardown.
+   */
+  close(): Promise<void>;
+}
+
+/**
+ * Options for `startServer` / `withServer` / `setupServer`.
+ */
+export interface ServerOptions {
+  /**
+   * Host to bind to. Defaults to `'127.0.0.1'` (explicit IPv4 — avoids
+   * dual-stack ambiguity on macOS where `'localhost'` may resolve to `::1`).
+   */
+  host?: string;
+  /** Port to bind to. Defaults to `0` (OS-assigned). */
+  port?: number;
+}
+
+/**
+ * Procedural primitive: start an `http.Server`, return a lifecycle handle.
+ *
+ * Races `'listening'` against `'error'` — port-busy / `EACCES` rejects,
+ * never hangs.
+ */
+export function startServer(server: Server, opts?: ServerOptions): Promise<ServerLifecycle>;
+
+/**
+ * Scoped resource: spin up a server with `serverHandler`, run `clientHandler`
+ * with the base URL, tear the server down in `finally`. Cleanup runs whether
+ * `clientHandler` resolves, rejects, or throws synchronously.
+ *
+ * `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 — naming reflects role on
+ * the wire, not which side is being tested.
+ */
+export function withServer<T>(
+  serverHandler: RequestListener,
+  clientHandler: (base: string, lifecycle: ServerLifecycle) => Promise<T> | T,
+  opts?: ServerOptions
+): Promise<T>;
+
+/**
+ * Hook-registering helper for suite-shared servers. Registers `beforeAll` to
+ * start the server and `afterAll` to close it; returns a live-getter context
+ * whose properties reflect the running server's state at access time.
+ *
+ * Per-test state reset (e.g. clearing a `recorded[]` array) stays user-side:
+ * compose your own `beforeEach`. `setupServer` owns the suite lifecycle; the
+ * caller owns suite state.
+ *
+ * Don't destructure the returned object at module load time — its properties
+ * read the live lifecycle on each access; destructuring captures stale
+ * `undefined` values.
+ */
+export function setupServer(
+  serverHandler: RequestListener,
+  opts?: ServerOptions
+): Readonly<{
+  readonly server: Server | undefined;
+  readonly base: string | undefined;
+  readonly port: number | undefined;
+  readonly host: string | undefined;
+}>;

package/src/server.js

@@ -0,0 +1,69 @@
+// @ts-self-types="./server.d.ts"
+
+import http from 'node:http';
+import {once} from 'node:events';
+
+import {beforeAll, afterAll} from './test.js';
+
+const DEFAULT_HOST = '127.0.0.1';
+
+export const startServer = async (server, {host = DEFAULT_HOST, port = 0} = {}) => {
+  const listening = once(server, 'listening');
+  const failure = once(server, 'error').then(([err]) => {
+    throw err;
+  });
+  server.listen(port, host);
+  await Promise.race([listening, failure]);
+
+  const addr = server.address();
+  const actualPort = typeof addr === 'object' && addr ? addr.port : port;
+  const base = `http://${host}:${actualPort}`;
+
+  let closed = false;
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    server.closeAllConnections?.();
+    server.close();
+    await once(server, 'close');
+  };
+
+  return {server, base, port: actualPort, host, close};
+};
+
+export const withServer = async (serverHandler, clientHandler, opts) => {
+  const server = http.createServer(serverHandler);
+  const lifecycle = await startServer(server, opts);
+  try {
+    return await clientHandler(lifecycle.base, lifecycle);
+  } finally {
+    await lifecycle.close();
+  }
+};
+
+export const setupServer = (serverHandler, opts) => {
+  let lifecycle = null;
+  beforeAll(async () => {
+    lifecycle = await startServer(http.createServer(serverHandler), opts);
+  });
+  afterAll(async () => {
+    if (lifecycle) {
+      await lifecycle.close();
+      lifecycle = null;
+    }
+  });
+  return Object.freeze({
+    get server() {
+      return lifecycle?.server;
+    },
+    get base() {
+      return lifecycle?.base;
+    },
+    get port() {
+      return lifecycle?.port;
+    },
+    get host() {
+      return lifecycle?.host;
+    }
+  });
+};