@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.131

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.13",
-  "private": false,
-  "description": "Live JSON stream of Telegram + Discord messages for your local Claude Code / Codex session. The user launches metro; metro emits inbounds on stdout and accepts replies via CLI subcommands.",
+  "version": "0.1.0-beta.131",
+  "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -15,38 +14,26 @@
     "node": ">=22"
   },
   "bin": {
-    "metro": "./dist/cli/index.js"
+    "metro": "dist/cli.js"
   },
   "files": [
     "dist",
-    "docs",
-    "skills",
-    "README.md",
-    "LICENSE"
+    "runtime"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "tag": "beta"
   },
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "tsc",
-    "lint": "eslint src/",
-    "lint:fix": "eslint src/ --fix",
-    "typecheck": "tsc --noEmit",
-    "test": "METRO_STATE_DIR=\"$(mktemp -d /tmp/metro-test.XXXXXX)\" bun test test/"
-  },
-  "dependencies": {
-    "discord.js": "^14.14.0",
-    "pino": "^9.5.0",
-    "pino-pretty": "^13.1.3",
-    "ws": "^8.20.0"
+    "build": "tsc && node scripts/stage-runtime.mjs",
+    "prepublishOnly": "tsc && node scripts/stage-runtime.mjs",
+    "test": "tsc --noEmit && node scripts/stage-runtime.mjs && bun test test/"
   },
   "devDependencies": {
-    "@types/node": "^22.10.0",
-    "@types/ws": "^8.18.1",
+    "@stage-labs/config": "0.1.0-beta.2",
     "eslint": "^10.3.0",
-    "typescript": "^5",
-    "typescript-eslint": "^8.59.2"
-  },
-  "packageManager": "bun@1.3.9"
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
 }

package/runtime/marketplace/.claude-plugin/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "metro",
+  "description": "Metro — connector relay and chat bridge for agents",
+  "owner": { "name": "Bonustrack", "url": "https://metro.box" },
+  "plugins": [
+    {
+      "name": "metro",
+      "source": "./plugin",
+      "description": "Sign in as one metro agent and use the connectors it holds as MCP servers through metro's relay, credentials injected server-side."
+    }
+  ]
+}

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,18 @@
+{
+  "name": "metro",
+  "version": "0.1.0-beta.131",
+  "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, the standing rules loaded at each session start, and a refresh skill for when the daemon could not keep the server list current. No vendor credential ever sits in a config file.",
+  "author": {
+    "name": "Bonustrack",
+    "url": "https://metro.box"
+  },
+  "repository": "https://github.com/bonustrack/metro",
+  "license": "MIT",
+  "keywords": [
+    "metro",
+    "mcp",
+    "connectors",
+    "relay"
+  ],
+  "skills": "./skills/"
+}

package/runtime/marketplace/plugin/.mcp.json

@@ -0,0 +1 @@
+{}

package/runtime/marketplace/plugin/bin/guard.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+
+const BLOCKING = new Set(['AskUserQuestion', 'ExitPlanMode', 'EnterPlanMode']);
+const ORCHESTRATION = new Set([
+  'Agent',
+  'Workflow',
+  'ToolSearch',
+  'Skill',
+  'ScheduleWakeup',
+  'Monitor',
+  'CronCreate',
+  'CronList',
+  'CronDelete',
+  'TaskCreate',
+  'TaskGet',
+  'TaskList',
+  'TaskOutput',
+  'TaskStop',
+  'TaskUpdate',
+]);
+const IMAGE = /\.(png|jpe?g|gif|webp|bmp)$/i;
+const MCP = /^mcp__/;
+const METRO_MCP = /^mcp__metro__/;
+
+function deny(reason) {
+  process.stdout.write(
+    `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason } })}\n`,
+  );
+}
+
+function verdict(payload) {
+  const tool = typeof payload.tool_name === 'string' ? payload.tool_name : '';
+  const input = payload.tool_input !== null && typeof payload.tool_input === 'object' ? payload.tool_input : {};
+  if (BLOCKING.has(tool))
+    return `${tool} blocks the session waiting on the terminal, and nobody is watching it. Decide with your best judgement and state the assumption, or ask over chat with the metro tools and keep working in the meantime.`;
+  if (typeof payload.agent_id === 'string' && payload.agent_id !== '') return null;
+  if (tool === 'Agent' && input.run_in_background === false)
+    return 'A foreground subagent blinds the main thread: it cannot see or acknowledge inbound metro messages until the agent finishes. Re-issue the identical Agent call with run_in_background: true, then wait for the task notification.';
+  if (ORCHESTRATION.has(tool)) return null;
+  if (METRO_MCP.test(tool)) return null;
+  if (MCP.test(tool))
+    return `A connector call is work, not orchestration: ${tool} reads somebody's files, mail or records, and its answer can be long enough to crowd out the chat you are here to follow. Only metro's own tools run on this thread. Delegate it to a subagent with the Agent tool (run_in_background: true; the worker reaches every connector) and relay what it finds.`;
+  if (tool === 'Read' && typeof input.file_path === 'string' && IMAGE.test(input.file_path)) return null;
+  return `The main thread is orchestrator-only, so ${tool === '' ? 'this tool' : tool} is not available here. Delegate the work to a subagent with the Agent tool (run_in_background: true; the worker agent has full tool access) or to a Workflow, and report the result over metro.`;
+}
+
+let payload = {};
+try {
+  payload = JSON.parse(readFileSync(0, 'utf8'));
+} catch {
+  payload = {};
+}
+const reason = verdict(payload !== null && typeof payload === 'object' ? payload : {});
+if (reason !== null) deny(reason);

package/runtime/marketplace/plugin/bin/metro-plugin.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const mcpPath = join(pluginRoot, '.mcp.json');
+const NAME_PREFIX = 'metro.box ';
+
+const localUrl = () => `http://127.0.0.1:${Number(process.env.METRO_WEBHOOK_PORT) || 8420}`;
+
+function agentsDir() {
+  const explicit = process.env.METRO_AGENTS_DIR?.trim();
+  return explicit ? explicit : join(homedir(), '.metro', 'agents');
+}
+
+function localAgents() {
+  const dir = agentsDir();
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const path = join(dir, entry.name, 'agent.json');
+    if (!existsSync(path)) continue;
+    try {
+      const file = JSON.parse(readFileSync(path, 'utf8'));
+      if (typeof file.id === 'string' && typeof file.name === 'string' && typeof file.key === 'string')
+        out.push({ id: file.id, name: file.name, key: file.key });
+    } catch {
+      continue;
+    }
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function pickAgent() {
+  const agents = localAgents();
+  const wanted = process.env.METRO_AGENT?.trim();
+  if (wanted) {
+    const found = agents.find((a) => a.name === wanted || a.id === wanted);
+    if (!found) throw new Error(`no local agent named '${wanted}' in ${agentsDir()}`);
+    return found;
+  }
+  if (agents.length === 1) return agents[0];
+  throw new Error(
+    agents.length === 0
+      ? 'no agent on this machine yet — start metro serve and create or restore one in the web UI'
+      : `several agents on this machine — set METRO_AGENT to one of: ${agents.map((a) => a.name).join(', ')}`,
+  );
+}
+
+async function api(path, key) {
+  let res;
+  try {
+    res = await fetch(`${localUrl()}${path}`, { headers: { authorization: `Bearer ${key}` } });
+  } catch {
+    throw new Error(`no metro daemon on ${localUrl()} — start one with: metro serve`);
+  }
+  const body = await res.json().catch(() => null);
+  if (!res.ok) {
+    const detail = typeof body?.error === 'string' ? body.error : `the daemon answered ${res.status}`;
+    const err = new Error(detail);
+    err.status = res.status;
+    throw err;
+  }
+  return body;
+}
+
+function serverEntries(rawJson) {
+  const servers = JSON.parse(rawJson)?.mcpServers;
+  if (typeof servers !== 'object' || servers === null)
+    throw new Error('the daemon returned an unexpected mcpServers shape');
+  const out = {};
+  for (const [key, value] of Object.entries(servers)) {
+    const name = key.startsWith(NAME_PREFIX) ? key.slice(NAME_PREFIX.length) : key;
+    out[name] = {
+      type: value.type ?? 'http',
+      url: value.url,
+      headersHelper: 'node "${CLAUDE_PLUGIN_ROOT}/bin/metro-plugin.mjs" headers',
+    };
+  }
+  return out;
+}
+
+async function refresh() {
+  const agent = pickAgent();
+  const body = await api('/api/cli/mcp', agent.key);
+  const servers = serverEntries(body.json);
+  writeFileSync(mcpPath, `${JSON.stringify(servers, null, 2)}\n`);
+  const names = Object.keys(servers);
+  process.stdout.write(
+    `agent '${agent.name}': ${names.length} server(s) written to the plugin\n` +
+      (names.length ? `  ${names.join('\n  ')}\n` : '') +
+      'Run /reload-plugins to apply in this session.\n',
+  );
+}
+
+function headers() {
+  let agent;
+  try {
+    agent = pickAgent();
+  } catch (err) {
+    process.stderr.write(`metro: ${err.message}\n`);
+    process.stdout.write('{}\n');
+    return;
+  }
+  process.stdout.write(`${JSON.stringify({ Authorization: `Bearer ${agent.key}` })}\n`);
+}
+
+const command = process.argv[2];
+const run = { refresh, headers: () => Promise.resolve(headers()) }[command];
+
+if (run === undefined) {
+  process.stderr.write('usage: metro-plugin.mjs <refresh|headers>\n');
+  process.exit(1);
+}
+
+run().catch((err) => {
+  process.stderr.write(`metro: ${err.message}\n`);
+  process.exit(err.status === 401 ? 2 : 1);
+});

package/runtime/marketplace/plugin/bin/session-start.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const given = (value) => (typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined);
+const claudeDir = given(process.env.CLAUDE_CONFIG_DIR) ?? join(given(process.env.HOME) ?? homedir(), '.claude');
+const SKILL = join(claudeDir, 'skills', 'metro-orchestrator', 'SKILL.md');
+const FALLBACK = join(dirname(dirname(fileURLToPath(import.meta.url))), 'orchestrator.md');
+
+const body = (text) => text.replace(/^---[\s\S]*?\n---\n/, '').trim();
+
+function guidance() {
+  for (const path of [SKILL, FALLBACK]) {
+    if (!existsSync(path)) continue;
+    try {
+      const text = body(readFileSync(path, 'utf8'));
+      if (text !== '') return text;
+    } catch {
+      continue;
+    }
+  }
+  return '';
+}
+
+const text = guidance();
+if (text !== '')
+  process.stdout.write(
+    `${JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: `This machine runs as a metro agent. Standing rules, kept in the metro-orchestrator skill:\n\n${text}` } })}\n`,
+  );

package/runtime/marketplace/plugin/hooks/hooks.json

@@ -0,0 +1,25 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/bin/guard.mjs\"",
+            "statusMessage": "Checking the orchestrator boundary"
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/bin/session-start.mjs\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/runtime/marketplace/plugin/orchestrator.md

@@ -0,0 +1,16 @@
+---
+name: metro-orchestrator
+description: How this box's agent works on metro. Acknowledge, delegate, relay, answer over chat, never block on the terminal. Loaded at every session start by the metro plugin; edit it here to change the rules on this box.
+---
+
+You are the main thread of a Claude Code session that is connected to chat through metro, on a machine nobody watches. The main thread is an orchestrator: it may only delegate and talk. A guard in the metro plugin denies every other tool on this thread, so this is the shape of the work, not a preference.
+
+**Inbound.** A message arrives as a `<channel source="metro" …>` block. Read `addressed` first: `direct`, `mention` or `reply` means it is for you; without it the message merely happened in a room you watch, so treat it as context and stay silent unless the person plainly wants you. For a message that is for you, the first tool call is `react` on it (👀, then 👍 or ✅ once done) so the person knows you saw it, and any reply goes on the same `line`, passed verbatim.
+
+**Delegate everything that is work.** Reading files, running commands, searching, fetching pages, editing, and every connector tool: hand it to a subagent with the `Agent` tool, `subagent_type: "worker"`, always `run_in_background: true`, then keep answering chat while it runs and relay the result when the task notification arrives. A foreground subagent blinds you to chat and the guard refuses it. You may read image files yourself, so a screenshot someone sends is yours to look at.
+
+**Never wait on the terminal.** `AskUserQuestion`, plan mode and anything that blocks for a person at the keyboard are denied everywhere, main thread and subagents alike. When something is ambiguous, do what does not depend on it, choose the most reasonable reading, say so in your reply, and if a real decision is needed ask over chat with `send` and carry on. Tool-approval prompts reach the chat too; the person answers `yes <id>` or `no <id>` there.
+
+**Report like a relay.** A worker's report is the only evidence you have, so pass on what it verified and say plainly what it did not. Short messages on chat: lead with the outcome, one idea per sentence, no tool names, no file paths unless the person needs them. Send a file out with `create_upload` (the curl line it hands back runs in a worker) and then `send` with the upload id.
+
+**Keep going.** Long tasks run as background agents and loops; check in over chat when something lands rather than going quiet. The session is restarted by the daemon if it exits, so an interrupted task is resumed from chat, not from memory.

package/runtime/marketplace/plugin/skills/refresh/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: refresh
+description: Rewrite the plugin's MCP servers from the metro daemon's connector list by hand, for when the daemon could not keep the list current itself.
+---
+
+The metro daemon writes this plugin's MCP server list itself whenever a connector is added, renamed or removed, so this is the fallback for when it could not: the daemon was not running at the time, or a plugin update reset the file.
+
+1. Run with Bash:
+
+```
+node "${CLAUDE_PLUGIN_ROOT}/bin/metro-plugin.mjs" refresh
+```
+
+2. On success, relay the script's output verbatim and tell the user to run `/reload-plugins --force`, which re-reads the plugin from disk; a plain `/reload-plugins` reuses a cached manifest and keeps the old list. You cannot run that command for them.
+3. If the script says there is no daemon, tell the user to start one with `metro serve` and stop. If it says there is no agent yet, tell them to create or restore one in the web UI the daemon links to.

package/runtime/node_modules/@metro-labs/core/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@metro-labs/core",
+  "version": "0.1.0",
+  "private": true,
+  "description": "What every metro process shares: the logger, the event bus and its types, ids, secure file writes, the train protocol, station types and attachment handling. No HTTP, no policy.",
+  "type": "module",
+  "exports": {
+    "./log": "./src/log.ts",
+    "./events": "./src/events.ts",
+    "./identity": "./src/identity.ts",
+    "./is-record": "./src/is-record.ts",
+    "./secure-fs": "./src/secure-fs.ts",
+    "./version": "./src/version.ts",
+    "./train-error": "./src/train-error.ts",
+    "./trains/protocol": "./src/protocol.ts",
+    "./ids": "./src/ids.ts",
+    "./address": "./src/address.ts",
+    "./station-names": "./src/station-names.ts",
+    "./str": "./src/str.ts",
+    "./lines": "./src/lines.ts",
+    "./endpoints": "./src/endpoints.ts",
+    "./stations/types": "./src/stations/types.ts",
+    "./stations/station-runtime": "./src/stations/station-runtime.ts",
+    "./stations/account-store": "./src/stations/account-store.ts",
+    "./stations/attachments": "./src/stations/attachments.ts",
+    "./stations/messaging-normalize": "./src/stations/messaging-normalize.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && METRO_STATE_DIR=\"$(mktemp -d /tmp/metro-test.XXXXXX)\" bun test test/"
+  },
+  "dependencies": {
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.2",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}

package/runtime/node_modules/@metro-labs/core/src/address.ts

@@ -0,0 +1,6 @@
+const ADDRESS_RE = /^0x[0-9a-f]{40}$/;
+
+export function normalizeAddress(raw: string): string | null {
+  const address = raw.trim().toLowerCase();
+  return ADDRESS_RE.test(address) ? address : null;
+}

package/runtime/node_modules/@metro-labs/core/src/endpoints.ts

@@ -0,0 +1,7 @@
+export interface Endpoint {
+  id: string;
+  webhookId?: string;
+  label: string;
+  secret?: string;
+  createdAt: string;
+}

package/runtime/node_modules/@metro-labs/core/src/events.ts

@@ -0,0 +1,120 @@
+import { randomBytes } from 'node:crypto';
+import { Line } from './lines.js';
+
+export { userSelf, daemonSelf } from './identity.js';
+
+export type StructuredEvent =
+  | { type: 'msg' }
+  | { type: 'react'; emoji?: string; targetId?: string }
+  | { type: 'edit'; targetId?: string }
+  | { type: 'delete'; targetId?: string }
+  | { type: 'reply'; replyTo?: string }
+  | { type: 'system'; source?: string; eventName?: string };
+
+export interface MetroEvent {
+  id: string;
+  ts: string;
+  station: string;
+  line: Line;
+  lineName?: string;
+  from: Line;
+  fromName?: string;
+  fromDisplayName?: string;
+  to: Line;
+  text?: string;
+  messageId?: string;
+  replyTo?: string;
+  isPrivate?: boolean;
+  mentionsSelf?: boolean;
+  replyToSelf?: boolean;
+  payload?: unknown;
+  display?: string;
+  event?: StructuredEvent;
+  agent?: string;
+  seq?: number;
+}
+
+function isExternalWebhook(e: MetroEvent): boolean {
+  return e.station === 'webhook' && !Line.isLocal(e.from);
+}
+
+function webhookEventName(e: MetroEvent): string | undefined {
+  const headers = (e.payload as { headers?: Record<string, string> } | undefined)
+    ?.headers;
+  return headers?.['x-github-event'] ?? headers?.['x-intercom-topic'];
+}
+
+export function classifyEvent(e: MetroEvent): StructuredEvent {
+  if (isExternalWebhook(e)) {
+    return {
+      type: 'system',
+      source: 'webhook',
+      eventName: webhookEventName(e),
+    };
+  }
+  const emoji =
+    (e.payload as { emoji?: string } | undefined)?.emoji ??
+    e.text?.match(/^\[react (.+)\]$/)?.[1];
+  if (emoji) return { type: 'react', emoji, targetId: e.replyTo };
+  if (e.replyTo) return { type: 'reply', replyTo: e.replyTo };
+  return { type: 'msg' };
+}
+
+export function formatDisplay(e: MetroEvent): string {
+  const headerFor = (icon: string, parts: (string | undefined)[]): string =>
+    `**${icon} ${parts.filter(Boolean).join(' · ')}**`;
+  const body = e.text ?? '';
+  if (isExternalWebhook(e)) {
+    const ev = webhookEventName(e);
+    return `${headerFor('🪝', ['webhook', e.lineName, ev])}\n> ${body}`;
+  }
+  if (Line.isLocal(e.from)) {
+    return `${headerFor('📤', [e.station, '→', e.fromName ?? e.to])}\n> ${body}`;
+  }
+  return `${headerFor('📩', [e.station, e.fromName ?? e.from, e.lineName])}\n> ${body}`;
+}
+
+export const mintId = (): string =>
+  `msg_${randomBytes(6).toString('base64url')}`;
+
+export type BusListener = (event: MetroEvent, busSeq: number) => void;
+
+export interface BufferedEvent {
+  busSeq: number;
+  event: MetroEvent;
+}
+
+const BUS_BUFFER_MAX = 500;
+
+const listeners = new Set<BusListener>();
+const buffer: BufferedEvent[] = [];
+let busSeq = 0;
+
+export function publishEvent(event: MetroEvent): void {
+  busSeq += 1;
+  const seq = busSeq;
+  buffer.push({ busSeq: seq, event });
+  if (buffer.length > BUS_BUFFER_MAX) buffer.shift();
+  for (const fn of [...listeners]) {
+    try {
+      fn(event, seq);
+    } catch (err) {
+      console.error('[metro-bus] listener threw for busSeq', seq, err);
+    }
+  }
+}
+
+export function currentBusSeq(): number {
+  return busSeq;
+}
+
+export function bufferedSince(afterBusSeq: number): BufferedEvent[] {
+  return buffer.filter((b) => b.busSeq > afterBusSeq);
+}
+
+export function subscribeEvents(fn: BusListener): () => void {
+  listeners.add(fn);
+  return () => {
+    listeners.delete(fn);
+  };
+}

package/runtime/node_modules/@metro-labs/core/src/identity.ts

@@ -0,0 +1,7 @@
+import { Line } from './lines.js';
+
+export const userSelf = (): Line =>
+  (process.env.METRO_FROM ?? 'metro://user') as Line;
+
+export const daemonSelf = (): Line =>
+  (process.env.METRO_FROM ?? process.env.METRO_SELF_URI ?? 'metro://user') as Line;

package/runtime/node_modules/@metro-labs/core/src/ids.ts

@@ -0,0 +1,21 @@
+import { randomBytes } from 'node:crypto';
+
+const ID_BYTES = 8;
+const REROLLS = 16;
+
+export const ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{10}$/;
+
+export function newId(): string {
+  for (let attempt = 0; attempt < REROLLS; attempt += 1) {
+    const id = randomBytes(ID_BYTES).toString('base64url');
+    if (ID_RE.test(id)) return id;
+  }
+  throw new Error('could not generate an id');
+}
+
+export function parseId(raw: unknown): string | null {
+  if (typeof raw !== 'string') return null;
+  return ID_RE.test(raw) ? raw : null;
+}
+
+export const AGENT_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{1,31}$/;

package/runtime/node_modules/@metro-labs/core/src/is-record.ts

@@ -0,0 +1,2 @@
+export const isRecord = (v: unknown): v is Record<string, unknown> =>
+  typeof v === 'object' && v !== null && !Array.isArray(v);