simt-dev 0.2.0 → 0.2.2

package/src/graph/speccheck.mjs

@@ -0,0 +1,68 @@
+// Walking the registry to the files on disk, so the conformance checker sees text.
+//
+// `graph lint` already resolves every skill to a path and measures it; this module does
+// the same walk for a different reason - it needs the bytes, not the count - and it is
+// separate rather than folded into that pass because one of the two questions may run
+// without the other.
+
+import { readFile, stat } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+
+import { checkSkill } from './spec.mjs';
+
+/**
+ * Check every skill the registry names against the Agent Skills specification.
+ *
+ * Only the canonical source is checked, because a skill with two bodies would give two
+ * answers to one question and the reader would have to know which is which. A skill
+ * whose body cannot be read is a warning and not an error: the registry pass already
+ * reports a path that does not exist as an error, and saying it twice with two exit
+ * paths is the "two commands, two answers" defect this repository exists to end.
+ *
+ * @param {{skills: object[]}} registry
+ * @param {string} workspaceRoot
+ * @returns {Promise<{errors: string[], warnings: string[], checked: number}>}
+ */
+export async function lintSpec(registry, workspaceRoot) {
+  const errors = [];
+  const warnings = [];
+  let checked = 0;
+
+  for (const skill of registry.skills ?? []) {
+    const source = (skill.sources ?? []).find((s) => s.role === 'canonical');
+    if (!source?.repo || !source?.path) continue;
+    const at = `${skill.name}: ${source.repo}/${source.path}`;
+    const full = join(workspaceRoot, source.repo, source.path);
+
+    let info;
+    try {
+      info = await stat(full);
+    } catch {
+      warnings.push(`${at}: the conformance pass could not read it; the registry pass above reports the path`);
+      continue;
+    }
+
+    // A skill directory holds its instructions in SKILL.md. A single file is the flat
+    // form ADR-009 says will be wrapped: it is still checked, because its frontmatter
+    // breaks the same rules, and the file name is reported as one of them.
+    const file = info.isDirectory() ? join(full, 'SKILL.md') : full;
+    let text;
+    try {
+      text = await readFile(file, 'utf8');
+    } catch {
+      warnings.push(`${at}: no SKILL.md in the directory, so there is nothing to check`);
+      continue;
+    }
+
+    const report = checkSkill({
+      directoryName: info.isDirectory() ? basename(full) : undefined,
+      fileName: basename(file),
+      text,
+      at,
+    });
+    errors.push(...report.errors);
+    warnings.push(...report.warnings);
+    checked += 1;
+  }
+  return { errors, warnings, checked };
+}

package/src/hooks/capability.mjs

@@ -18,9 +18,10 @@
 // cannot run a `lint` gate, and this reads the manifest rather than the dependency graph
 // so the two can never disagree about what a script does.
 
-import { readdir, readFile, stat } from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import { access, readdir, readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { manifestPath } from '../projection/manifest.mjs';
+import { ECOSYSTEMS, manifestPath } from '../projection/manifest.mjs';
 
 /** Binaries the shared dispatcher shells out to directly, rather than via a script. */
 const BIN_DIR = join('node_modules', '.bin');
@@ -59,14 +60,49 @@ async function fileExists(path) {
   }
 }
 
+/**
+ * Does an EXECUTABLE file exist at this path?
+ *
+ * A wrapper that exists but is not executable is a probe failure, not a success:
+ * declaring it would plant a command that fails closed on every commit — the defect
+ * ADR-017 exists to prevent, reached from the ecosystem table rather than the stack.
+ */
+async function executableFile(path) {
+  try {
+    if (!(await stat(path)).isFile()) return false;
+    await access(path, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Can this machine run the ecosystem's program?
+ *
+ * Two kinds of evidence, matching the two kinds of tool in `ECOSYSTEMS`: a binary on
+ * PATH, probed directory by directory the way the shell would find it, and a file the
+ * repository commits (the Maven wrapper), probed in place the way `gradlew` is probed.
+ * Either answer that is not a positive YES is NO: a seed that guesses a toolchain is
+ * a declared gate that cannot run, and the dispatcher fails closed on it.
+ */
+async function probeTool(root, eco) {
+  if (eco.file) return executableFile(join(root, eco.tool));
+  const dirs = (process.env.PATH ?? '').split(':').filter(Boolean);
+  for (const dir of dirs) {
+    if (await executableFile(join(dir, eco.tool))) return true;
+  }
+  return false;
+}
+
 /**
  * Read what this repo can run.
  *
  * @param {string} root
- * @returns {Promise<{scripts: Record<string,string>, binaries: string[], commands: Record<string,string>, runner: string, error: string|null}>}
+ * @returns {Promise<{scripts: Record<string,string>, binaries: string[], commands: Record<string,string>, tools: string[], runner: string, error: string|null}>}
  */
 export async function readCapability(root) {
-  const capability = { scripts: {}, binaries: [], commands: {}, runner: null, error: null };
+  const capability = { scripts: {}, binaries: [], commands: {}, tools: [], runner: null, error: null };
 
   try {
     const manifest = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
@@ -104,6 +140,14 @@ export async function readCapability(root) {
     // No node_modules is the same as no installed binaries.
   }
 
+  // `tools` answers "can this MACHINE run the ecosystem's program", which the marker
+  // file in the repo cannot: a Cargo.toml without cargo installed is an ecosystem that
+  // is here but whose gates would all fail closed. The probe is per-row, because a row
+  // that marks its tool `file` lives in the repository, not on PATH.
+  for (const eco of ECOSYSTEMS) {
+    if (await probeTool(root, eco)) capability.tools.push(eco.tool);
+  }
+
   // `gates.commands` lives in simt-dev.json, NOT package.json, so it has to be read
   // here or a command gate looks undeclared to `check` while the dispatcher runs it
   // successfully — the gate and the checker disagreeing about the same manifest.

package/src/hooks/dispatcher.mjs

@@ -19,19 +19,20 @@
 //   its reason, so "passed" can never be mistaken for "only some of it passed".
 
 import { execFile } from 'node:child_process';
-import { readFile } from 'node:fs/promises';
-import { basename, join } from 'node:path';
+import { readFile, stat } from 'node:fs/promises';
+import { basename, join, resolve, sep } from 'node:path';
 import { promisify } from 'node:util';
 
 import { GATES } from './gates.mjs';
 import { resolveGate } from './resolve.mjs';
 import { CLI } from '../name.mjs';
 import { MANIFEST_FILE } from '../name.mjs';
+import { assertVersionPin } from '../package-version.mjs';
 
 const exec = promisify(execFile);
 
 /** Gates that are known but not required for the event to pass. */
-export const DEFAULT_EVENTS = { 'pre-commit': 'preCommit', 'pre-push': 'prePush' };
+const DEFAULT_EVENTS = { 'pre-commit': 'preCommit', 'pre-push': 'prePush' };
 
 /**
  * @param {string} event 'pre-commit' | 'pre-push'
@@ -65,10 +66,31 @@ export async function runGates(event, { root, manifest }) {
     };
   }
 
+  // The gates below run from the binary that resolved this shim. For a repository
+  // without npm that is a global install, whose version nothing else pins: if it is not
+  // the one this repo adopted, the gates that run here are not the ones CI runs.
+  // Placed after the empty-list check on purpose - with no gates there is nothing the
+  // version could get wrong, and failing that case would block commits in repos that
+  // deliberately declare none.
+  const mismatch = assertVersionPin(manifest);
+  if (mismatch) {
+    return {
+      event,
+      gates: [{ name: 'version', status: 'failed', detail: mismatch, remedy: `run: ${CLI} upgrade --yes`, adr: null }],
+      failed: true,
+    };
+  }
+
   const pkg = await readPkg(root);
   const staged = event === 'pre-commit' ? await stagedFiles(root) : [];
   const unstaged = event === 'pre-commit' ? await unstagedFiles(root) : new Set();
   const commands = manifest?.gates?.commands;
+  // `gates.cwd` is a separate map rather than a second shape for `gates.commands`.
+  // A monorepo needs the gate to run inside one package, and the reader declaring it
+  // already knows the gate by name — putting the directory beside the command would
+  // mean re-reading the command string to find out where anything runs, and a manifest
+  // written by an older release would have to be rewritten to gain the capability.
+  const cwds = manifest?.gates?.cwd ?? {};
   const results = [];
   // What the format gate rewrote, so restage touches those files and nothing else.
   let formatted = [];
@@ -131,7 +153,33 @@ export async function runGates(event, { root, manifest }) {
       formatted = targets;
     }
 
-    const outcome = await run(resolution.argv, root);
+    // The gate's directory, if it declares one. Resolved against the repo root and
+    // checked for containment: a `cwd` that escaped the repository would run a command
+    // against files this commit cannot see, and the gate would be green about them.
+    // Containment is checked on the RESOLVED path, not the string, because `..` and a
+    // symlink both get past a prefix test on the text.
+    let cwd = root;
+    const declaredCwd = cwds[name];
+    if (declaredCwd !== undefined) {
+      const resolved = resolve(root, declaredCwd);
+      const inside = resolved === root || resolved.startsWith(`${root}${sep}`);
+      const exists = inside && (await stat(resolved).catch(() => null))?.isDirectory();
+      if (!exists) {
+        results.push({
+          name,
+          status: 'failed',
+          detail: inside
+            ? `gates.cwd["${name}"] is ${declaredCwd}, which is not a directory in this repository`
+            : `gates.cwd["${name}"] is ${declaredCwd}, which is outside the repository`,
+          remedy: `point gates.cwd["${name}"] at a directory in this repository, or remove it to run the gate at the root`,
+          adr: gate.adr,
+        });
+        continue;
+      }
+      cwd = resolved;
+    }
+
+    const outcome = await runGate(resolution, cwd);
     results.push({
       name,
       status: outcome.code === 0 ? 'passed' : 'failed',
@@ -186,6 +234,37 @@ async function run(argv, cwd) {
   }
 }
 
+/**
+ * Run a gate's resolution, as a shell line or as an argv.
+ *
+ * A declared command is a line the repository wrote in its own manifest and would type
+ * into its own shell (ADR-019 ruling 8), so it goes through `sh -c` and everything it
+ * wrote survives — quotes, pipes, `&&`, a flag with a space in its value. Everything
+ * this tool resolved itself stays an argv, because that is a path this tool chose out of
+ * `node_modules/.bin` and handing it to a shell would be a change of trust for no gain.
+ *
+ * `sh -c` is not a sandbox and is not meant to be. The trust boundary is the repository:
+ * the line came from its own manifest, which it can read and change, and it runs on the
+ * author's own machine at the author's own request. The only property worth defending is
+ * that the two sources stay distinguishable, which is why this is a separate branch
+ * rather than a flag on `run`.
+ */
+async function runGate(resolution, cwd) {
+  if (resolution.shell === true && typeof resolution.command === 'string') {
+    try {
+      const { stdout, stderr } = await exec('sh', ['-c', resolution.command], { cwd, maxBuffer: 8 * 1024 * 1024 });
+      return { code: 0, stdout, stderr };
+    } catch (error) {
+      return {
+        code: typeof error.code === 'number' ? error.code : 1,
+        stdout: error.stdout ?? '',
+        stderr: error.stderr ?? String(error.message ?? error),
+      };
+    }
+  }
+  return run(resolution.argv, cwd);
+}
+
 async function readPkg(root) {
   try {
     return JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
@@ -212,7 +291,7 @@ export async function stagedFiles(root) {
  * A path staged as DELETED is not here: the index and the working tree agree that
  * it is gone, so there is no unstaged work to protect and no reason to refuse.
  */
-export async function unstagedFiles(root) {
+async function unstagedFiles(root) {
   try {
     const { stdout } = await exec('git', ['diff', '--name-only'], { cwd: root });
     return new Set(stdout.split('\n').map((s) => s.trim()).filter(Boolean));
@@ -264,5 +343,3 @@ function tail(text, lines = 12) {
   const parts = String(text).trimEnd().split('\n');
   return parts.slice(-lines).join('\n');
 }
-
-export const __internals = { tail, basename };

package/src/hooks/gates.mjs

@@ -140,5 +140,3 @@ export function unresolved(name, { hasScript, binary, command, stack }) {
 export function gateNames() {
   return Object.keys(GATES).sort();
 }
-
-export const __internals = { FORMATTABLE, GATES };

package/src/hooks/resolve.mjs

@@ -14,7 +14,7 @@ import { access } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { join } from 'node:path';
 
-import { FORMATTABLE, GATES, GATES as _G } from './gates.mjs';
+import { FORMATTABLE, GATES } from './gates.mjs';
 import { MANIFEST_FILE } from '../name.mjs';
 
 /** Gate names the shared dispatcher knows, sorted. */
@@ -22,23 +22,8 @@ export function knownGates() {
   return Object.keys(GATES).sort();
 }
 
-export function gateKind(name) {
-  return GATES[name]?.kind ?? null;
-}
-
-export function gateWhy(name) {
-  return GATES[name]?.why ?? null;
-}
-
-export function gateAdr(name) {
-  return GATES[name]?.adr ?? null;
-}
-
-/**
- * Is this path an executable file?
- * @param {string} path
- */
-export async function isExecutable(path) {
+/** Is this path an executable file? */
+async function isExecutable(path) {
   try {
     await access(path, constants.X_OK);
     return true;
@@ -96,8 +81,20 @@ export async function resolveGate(gate, { root, pkg, staged, commands }) {
   // own remedy, to "name the program under gates.commands"; a dispatcher that then
   // ignored that declaration would contradict the remedy, and so would `check`.
   if (declared) {
-    const argv = declared.trim().split(/\s+/).filter(Boolean);
-    if (argv.length === 0) {
+    // The declaration is a SHELL COMMAND LINE, not an argv (ADR-019, ruling 8).
+    //
+    // It was split on whitespace, so every declaration a repository would plausibly
+    // write was wrong: `npm run test -- --watch=false` became seven arguments with the
+    // flag value as a separate one, and `sh -c "a && b"` became eleven, with the quotes
+    // passed to the program. A repository had no way to write a gate with a quoted
+    // argument, and nothing said so — the gate simply ran the wrong thing.
+    //
+    // Splitting is also a parse without an owner. `execFile` takes an argv because it
+    // must not use a shell, which is right for a path this tool chose and wrong for a
+    // line the repository wrote in full view of its own shell. The two cases are now
+    // different types rather than one `argv` field carrying both.
+    const line = declared.trim();
+    if (line === '') {
       return {
         ok: false,
         gate: name,
@@ -109,12 +106,16 @@ export async function resolveGate(gate, { root, pkg, staged, commands }) {
     return {
       ok: true,
       kind: gate.kind,
-      argv,
+      // Kept alongside `command` because the dispatcher prints and passes it to
+      // `hooks status`, and two representations of one thing is how they drift.
+      argv: line.split(/\s+/).filter(Boolean),
+      command: line,
+      shell: true,
       // The dispatcher has to know whether these argv entries are paths it chose or
       // words it was handed. Sniffing the detail string meant the safety guard on
       // partial stages would quietly stop working the day that wording changed.
       declared: true,
-      detail: `declared command: ${declared}`,
+      detail: `declared command: ${line}`,
     };
   }
 
@@ -189,6 +190,4 @@ export async function resolveGate(gate, { root, pkg, staged, commands }) {
 function extname(path) {
   const dot = path.lastIndexOf('.');
   return dot > 0 ? path.slice(dot).toLowerCase() : '';
-}
-
-export const __internals = { extname, FORMATTABLE };
+}

package/src/hooks/shim.mjs

@@ -17,7 +17,20 @@
 // start in CI. See src/locate.mjs.
 
 import { renderLocator } from '../locate.mjs';
-import { BIN_ENV, CLI, MANIFEST_FILE } from '../name.mjs';
+import { BIN_ENV, CLI, MANIFEST_FILE, PACKAGE_NAME } from '../name.mjs';
+import { packageVersion } from '../package-version.mjs';
+
+/**
+ * A line only this tool's dispatcher shim carries.
+ *
+ * The banner, not the path and not the name. `pre-commit` is what a hand-written gate
+ * is called too, and the file can sit wherever git looks, so neither of those can say
+ * who wrote it. Exported rather than matched as a literal somewhere else because the
+ * question this answers is asked from both sides: this file writes it, and
+ * `readHooksState` reads it back to decide whether a hook it cannot recognise as
+ * current is nonetheless its own.
+ */
+export const SHIM_MARKER = '# Generated by simt-dev. Do not edit.';
 
 /** Events the shared dispatcher knows how to run. */
 export const EVENTS = ['pre-commit', 'pre-push'];
@@ -34,15 +47,26 @@ export function fileFor(event) {
 
 /**
  * @param {string} event one of EVENTS
+ * @param {{npm?: boolean, version?: string}} [opts]
+ *   `npm` is whether the repository has a package.json: it decides the remedy's install
+ *   (a devDependency where one exists, a pinned global install where there is no
+ *   node_modules to pin in). `version` defaults to the running package's own version,
+ *   so a shim generated by 0.2.0 names 0.2.0 in its remedy and CI install.
  * @returns {string} POSIX sh source, LF-terminated, executable
  */
-export function renderShim(event) {
+export function renderShim(event, { npm = true, version } = {}) {
   if (!EVENTS.includes(event)) {
     throw new Error(`unknown hook event ${event}; known: ${EVENTS.join(', ')}`);
   }
+  const v = version ?? packageVersion();
+  // The install that finds the binary when node_modules and PATH both come up empty.
+  // A repository with a package.json pins simt-dev as a devDependency, so the remedy
+  // installs it there; one without (Gradle, Connect IQ) has no node_modules to pin in,
+  // so the remedy is a pinned global install - the same pinned bytes CI gets.
+  const install = npm ? `npm i -D ${PACKAGE_NAME}@${v}` : `npm i -g ${PACKAGE_NAME}@${v}`;
   const D = '$';
   return `#!/bin/sh
-# Generated by simt-dev. Do not edit.
+${SHIM_MARKER}
 #
 # Every decision this hook makes is declared in ${MANIFEST_FILE}, so a reviewer reads
 # the gate list in a diff instead of reverse-engineering shell. Reinstall with:
@@ -51,7 +75,7 @@ export function renderShim(event) {
 # This file only locates the dispatcher and hands over. It resolves in order:
 #   1. ${D}SIMT_DEV_BIN    explicit override, for CI images and odd checkouts
 #   2. node_modules/       the pinned project dependency
-#   3. simt-dev on PATH    a global install
+#   3. ${CLI} on PATH       a global install
 # If none resolves it REFUSES rather than exiting 0. A hook that cannot verify
 # anything must never report success - that is what teaches authors to reach for
 # --no-verify.
@@ -62,7 +86,7 @@ ROOT="${D}(git rev-parse --show-toplevel 2>/dev/null || pwd)"
 
 ${renderLocator(`hooks run ${event} --root "${D}ROOT"`, {
     subject: 'the dispatcher',
-    remedy: `REMEDY set ${BIN_ENV} to the ${CLI} binary, or unset ${HOOKS_PATH_KEY} to opt out`,
+    remedy: `REMEDY run: ${install}, or set ${BIN_ENV} to the ${CLI} binary, or unset ${HOOKS_PATH_KEY} to opt out`,
   })}`;
 }
 

package/src/identity.mjs

@@ -173,17 +173,6 @@ export async function includeOwnIdentity(root) {
   await git(root, ['config', '--local', '--replace-all', INCLUDE_KEY, `../${IDENTITY_FILE}`]);
 }
 
-/**
- * Whether the repository tracks the identity file, which it should not.
- *
- * @param {string} root
- * @returns {Promise<boolean>}
- */
-export async function tracksIdentity(root) {
-  const listed = await git(root, ['ls-files', '--error-unmatch', IDENTITY_FILE]);
-  return listed === IDENTITY_FILE;
-}
-
 /**
  * Add the identity file to .gitignore, if it is not already there.
  *

package/src/mcp/schema.mjs

@@ -0,0 +1,139 @@
+// A JSON Schema checker, for the subset these schemas use.
+//
+// Written here rather than taken from npm because a tool that validates a payload has
+// to keep working on a machine where nothing was installed (ADR-012), and because the
+// schemas it checks are in this file: a dependency would be a second place for the same
+// rules to live, and the one thing a validator must not be is quietly out of date.
+//
+// The subset is deliberately small and deliberately loud. A keyword this file does not
+// understand is reported as an error rather than skipped, because a keyword silently
+// ignored turns a schema into decoration - the check passes, the payload does not match,
+// and nobody can say which of the two was wrong. `assertValid` is the only entry point
+// the tests use, and it names the failing path.
+//
+// Supported: type (including union arrays), properties, required, items, enum,
+// additionalProperties (boolean or a schema), anyOf.
+
+/**
+ * Check a value against a schema.
+ *
+ * @param {unknown} value
+ * @param {object} schema
+ * @param {string} [path] JSON pointer-ish location, for the message
+ * @returns {string|null} the first failure, or null when it validates
+ */
+export function check(value, schema, path = '$') {
+  if (schema === true || schema === undefined) return null;
+  if (schema === false) return `${path}: no value is allowed here`;
+  if (typeof schema !== 'object' || schema === null) return `${path}: schema must be an object`;
+
+  for (const keyword of Object.keys(schema)) {
+    if (!SUPPORTED.has(keyword)) {
+      // Loud on purpose: see the header. A keyword nobody implements is a promise the
+      // schema does not keep, and this is the only place that can notice.
+      throw new Error(`schema at ${path} uses "${keyword}", which this checker does not implement`);
+    }
+  }
+
+  if (schema.type !== undefined && !typeMatches(value, schema.type)) {
+    return `${path}: expected ${describe(schema.type)}, got ${describeValue(value)}`;
+  }
+  if (Array.isArray(schema.enum) && !schema.enum.some((allowed) => same(allowed, value))) {
+    return `${path}: ${JSON.stringify(value)} is not one of ${JSON.stringify(schema.enum)}`;
+  }
+  if (Array.isArray(schema.anyOf)) {
+    const matched = schema.anyOf.some((option) => check(value, option, path) === null);
+    if (!matched) return `${path}: matched none of the ${schema.anyOf.length} allowed shapes`;
+  }
+
+  if (schema.type === 'object' || schema.properties !== undefined || schema.required !== undefined) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) return null;
+    for (const key of schema.required ?? []) {
+      if (!(key in value)) return `${path}: missing required property "${key}"`;
+    }
+    for (const [key, sub] of Object.entries(schema.properties ?? {})) {
+      if (!(key in value)) continue;
+      const failure = check(value[key], sub, `${path}.${key}`);
+      if (failure !== null) return failure;
+    }
+    if (schema.additionalProperties !== undefined) {
+      const known = new Set(Object.keys(schema.properties ?? {}));
+      for (const [key, sub] of Object.entries(value)) {
+        if (known.has(key)) continue;
+        if (schema.additionalProperties === false) return `${path}: unexpected property "${key}"`;
+        if (schema.additionalProperties !== true) {
+          const failure = check(sub, schema.additionalProperties, `${path}.${key}`);
+          if (failure !== null) return failure;
+        }
+      }
+    }
+  }
+
+  if (schema.items !== undefined && Array.isArray(value)) {
+    for (const [index, item] of value.entries()) {
+      const failure = check(item, schema.items, `${path}[${index}]`);
+      if (failure !== null) return failure;
+    }
+  }
+  return null;
+}
+
+/** Throws with the first failure, named. The shape a test wants. */
+export function assertValid(value, schema, what = 'value') {
+  const failure = check(value, schema);
+  if (failure !== null) throw new Error(`${what} does not match its schema: ${failure}`);
+  return true;
+}
+
+const SUPPORTED = new Set([
+  'type',
+  'properties',
+  'required',
+  'items',
+  'enum',
+  'additionalProperties',
+  'anyOf',
+  'description',
+  '$schema',
+]);
+
+function typeMatches(value, type) {
+  const types = Array.isArray(type) ? type : [type];
+  return types.some((t) => singleTypeMatches(value, t));
+}
+
+function singleTypeMatches(value, type) {
+  switch (type) {
+    case 'object':
+      return value !== null && typeof value === 'object' && !Array.isArray(value);
+    case 'array':
+      return Array.isArray(value);
+    case 'string':
+      return typeof value === 'string';
+    case 'number':
+      return typeof value === 'number' && Number.isFinite(value);
+    case 'integer':
+      return Number.isInteger(value);
+    case 'boolean':
+      return typeof value === 'boolean';
+    case 'null':
+      return value === null;
+    default:
+      return false;
+  }
+}
+
+function describe(type) {
+  return Array.isArray(type) ? type.join('|') : type;
+}
+
+/** What a value IS, for the failure message. Distinct from `describe(type)`. */
+function describeValue(value) {
+  if (value === null) return 'null';
+  if (Array.isArray(value)) return 'array';
+  return typeof value;
+}
+
+function same(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}