@basein/runner 0.2.12 → 0.3.1

package/dist/control/pin-guard.js

@@ -0,0 +1,534 @@
+/**
+ * pin-guard — whether a live call is plausibly the step a steering plan
+ * expects, before the control server rewrites it to the step's input.
+ *
+ * WHY THIS EXISTS. A steer plan pins "the next call to the expected tool", and
+ * the pin replaces the model's arguments with the step's and answers `allow`.
+ * Matching on the tool name alone meant that a model checking its work with
+ * `Bash ls` while a `Bash git push --force` step was due had Claude Code show
+ * `ls` and run the push, unasked. A tool name says which *kind* of call this
+ * is; it says nothing about whether the call is the step.
+ *
+ * The rule is deliberately conservative, because the two mistakes are not the
+ * same size. Not pinning a call that was the step costs a replay: the call
+ * runs as the model wrote it, and the plan stays armed for the call that is
+ * the step (the control server retires it, running nothing, if the model moves
+ * on to another tool instead). Pinning one that was not the step runs
+ * something the user never saw.
+ *
+ *   - `Bash` / `PowerShell`: the same command, or the same *commands*: as
+ *     many of them, chained the same way (`&&`, `||`, `;`, `|`, `&`, a new
+ *     line), each with the same head (the program, plus its subcommand when
+ *     it has one: `git push`, `npm test`; plus what it runs when it only runs
+ *     something else: `npm run lint`, `python deploy.py`). Comparing only the
+ *     first command's head pinned a model's `git status` to a step's `git
+ *     status && git push --force`. A step that runs a command substitution
+ *     (`$(…)`, backticks) is pinned only to an exact copy.
+ *   - Tools that write a file: the same file.
+ *   - MCP tools whose input is run — a query, a statement, a shell command
+ *     (replay/safety.ts `sinkOf`): every statement the step runs, supplied by
+ *     the model with the same verb (`SELECT` for `SELECT`, never for
+ *     `DELETE`), or no arguments at all. One shared key such as `sql` said
+ *     nothing about what the call does. An empty statement argument of the
+ *     step (`input: ""` beside the query) runs nothing and need not be
+ *     supplied — but a call that runs something there is not the step.
+ *   - Everything else: at least one argument in common, and no argument that
+ *     names *where* the call acts (a path, a URL) pointing somewhere else. A
+ *     call with no arguments at all is the model deferring to the directive
+ *     ("the system supplies the exact arguments") and is pinned.
+ *
+ * Read-only file tools are not held to the same file: pinning a `Read` of the
+ * wrong path to the step's path is exactly what the directive asks for, and it
+ * changes nothing on disk.
+ */
+import { stableStringify } from "./correlation.js";
+import { sinkOf } from "../replay/safety.js";
+/** Tools whose target file is the call's whole effect: another file is another call. */
+const FILE_WRITERS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+/** Argument keys that name where a call acts. Two different values are two different calls. */
+const TARGET_KEYS = ["file_path", "notebook_path", "path", "url", "uri"];
+/** Read-only built-ins whose target may be steered freely. */
+const READERS = new Set(["Read", "Grep", "Glob", "LS", "WebFetch", "WebSearch", "NotebookRead"]);
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+/** Paths compare without caring about separators, trailing slashes or (on Windows) case. */
+function normalTarget(value) {
+    let out = value.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+    if (process.platform === "win32")
+        out = out.toLowerCase();
+    return out;
+}
+/** Split a shell command into words, honouring simple quotes. Good enough to find its head. */
+function words(command) {
+    const out = [];
+    let word = "";
+    let quote;
+    let inWord = false;
+    for (const ch of command) {
+        if (quote) {
+            if (ch === quote)
+                quote = undefined;
+            else
+                word += ch;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            inWord = true;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (inWord)
+                out.push(word);
+            word = "";
+            inWord = false;
+            continue;
+        }
+        word += ch;
+        inWord = true;
+    }
+    if (inWord)
+        out.push(word);
+    return out;
+}
+const SEPARATORS = new Set(["&&", "||", ";", "|", "&"]);
+/**
+ * Programs whose own name says nothing about what runs: the script, module or
+ * inline command they are handed does. `python a.py` and `python deploy.py`
+ * are two different calls, and so are `bash -c "ls"` and `bash -c "rm -rf x"`.
+ */
+const INTERPRETERS = new Set([
+    "python", "python3", "py", "pypy", "pypy3", "node", "deno", "bun", "tsx", "ts-node",
+    "ruby", "perl", "php", "bash", "sh", "zsh", "dash", "ksh", "fish", "pwsh", "powershell", "cmd",
+]);
+/** The flags that hand an interpreter its code inline. What follows is what runs. */
+const INLINE_FLAGS = new Set(["-c", "-e", "-command", "/c", "/k"]);
+/** Package runners: `npx eslint` runs eslint. */
+const PACKAGE_RUNNERS = new Set(["npx", "pnpx", "bunx", "uvx"]);
+/** `<program> <subcommand> <what>`: the subcommand runs its first operand. */
+const RUN_SUBCOMMANDS = {
+    npm: new Set(["run", "run-script", "exec", "x"]),
+    pnpm: new Set(["run", "exec", "dlx"]),
+    yarn: new Set(["run", "exec", "dlx"]),
+    bun: new Set(["run", "x"]),
+    deno: new Set(["run", "task"]),
+    uv: new Set(["run"]),
+    poetry: new Set(["run"]),
+    pipenv: new Set(["run"]),
+    pipx: new Set(["run"]),
+    cargo: new Set(["run"]),
+    go: new Set(["run"]),
+};
+/** How deep `uv run python …` or `bash -c "sh -c '…'"` is followed. */
+const MAX_HEAD_DEPTH = 3;
+/** A word that reads like a subcommand: not a path, a flag or a file name. */
+const SUBCOMMAND = /^[A-Za-z][A-Za-z0-9_:-]*$/;
+/** A program's bare name: no directory, no Windows extension, lower case. */
+function programName(word) {
+    return word
+        .replace(/\\/g, "/")
+        .split("/")
+        .pop()
+        .toLowerCase()
+        .replace(/\.(exe|cmd|bat|ps1)$/, "");
+}
+/** A script operand compares by its file name: `./scripts/deploy.py` is `deploy.py`. */
+function operandName(word) {
+    return word.replace(/\\/g, "/").split("/").pop() ?? word;
+}
+/** The first word of `args` that is not a flag, or -1. */
+function operandIndex(args) {
+    return args.findIndex((a) => a !== "" && !a.startsWith("-"));
+}
+/**
+ * What a runner is told to run, named: a program that itself runs something
+ * else is followed (`uv run python deploy.py`), anything else is its name.
+ */
+function operandHead(args, depth) {
+    const i = operandIndex(args);
+    if (i < 0)
+        return undefined;
+    const what = args[i];
+    const name = programName(what);
+    const runsSomething = INTERPRETERS.has(name) || PACKAGE_RUNNERS.has(name) || RUN_SUBCOMMANDS[name];
+    if (runsSomething && depth < MAX_HEAD_DEPTH)
+        return headOf(args.slice(i), depth + 1);
+    return operandName(what);
+}
+/**
+ * The part of a command that says what it does: the program and, when the
+ * next word reads like a subcommand, that too — `git push`, `npm test`,
+ * `docker compose`. Leading environment assignments and a leading `cd <dir> &&`
+ * are skipped; a path, a flag or a file name is not a subcommand.
+ *
+ * A program that only runs something else is named with what it runs —
+ * `npm run lint` (never just `npm run`, which would pin a lint to a deploy),
+ * `npx eslint`, `python deploy.py`, `python -m pytest`, `uv run pytest` —
+ * and a shell's inline command is that command: `bash -c "git push"` is
+ * `git push`.
+ */
+export function commandHead(command, depth = 0) {
+    let parts = words(command.replace(/(&&|\|\||;|\|)/g, " $1 "));
+    // `cd somewhere && real-command` is the real command's call.
+    while (parts.length > 0) {
+        let i = 0;
+        while (i < parts.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(parts[i]))
+            i += 1;
+        parts = parts.slice(i);
+        const first = (parts[0] ?? "").toLowerCase();
+        if (first === "cd" || first === "pushd" || first === "set-location" || first === "sl") {
+            const sep = parts.findIndex((p) => SEPARATORS.has(p));
+            if (sep < 0)
+                break;
+            parts = parts.slice(sep + 1);
+            continue;
+        }
+        break;
+    }
+    return headOf(parts, depth);
+}
+/** {@link commandHead} of a command already split into words, program first. */
+function headOf(parts, depth) {
+    const program = programName(parts[0] ?? "");
+    // This command's own words, up to the next `&&`, `|`, `;`.
+    const end = parts.findIndex((p, i) => i > 0 && SEPARATORS.has(p));
+    const args = parts.slice(1, end < 0 ? undefined : end);
+    const sub = args[0]?.toLowerCase();
+    if (sub !== undefined && RUN_SUBCOMMANDS[program]?.has(sub)) {
+        const what = operandHead(args.slice(1), depth);
+        return what === undefined ? `${program} ${sub}` : `${program} ${sub} ${what}`;
+    }
+    if (PACKAGE_RUNNERS.has(program)) {
+        const what = operandHead(args, depth);
+        return what === undefined ? program : `${program} ${what}`;
+    }
+    if (INTERPRETERS.has(program)) {
+        const inline = args.findIndex((a) => INLINE_FLAGS.has(a.toLowerCase()));
+        if (inline >= 0) {
+            // The inline code is what runs. A shell's is a command with a head of
+            // its own; anything else (`python -c`, `node -e`) is compared whole.
+            const inner = args.slice(inline + 1).join(" ").trim();
+            if (!inner)
+                return program;
+            if (depth >= MAX_HEAD_DEPTH)
+                return `${program} ${inner}`;
+            return commandHead(inner, depth + 1) || program;
+        }
+        const module = args.indexOf("-m");
+        if (module >= 0 && args[module + 1])
+            return `${program} -m ${args[module + 1]}`;
+        const i = operandIndex(args);
+        if (i < 0)
+            return program;
+        const what = args[i];
+        // A bare word is a subcommand (`bun install`, `deno fmt`) or a script with
+        // no extension; a word with a dot or a slash is a script, named by its file.
+        return SUBCOMMAND.test(what) ? `${program} ${what.toLowerCase()}` : `${program} ${operandName(what)}`;
+    }
+    const next = args[0];
+    return next !== undefined && SUBCOMMAND.test(next) ? `${program} ${next.toLowerCase()}` : program;
+}
+/**
+ * A command line split into the commands it chains, at the separators that
+ * are not quoted or escaped: `&&`, `||`, `;`, `|` (and `|&`), a background
+ * `&`, a new line. A redirection's `&` (`2>&1`, `&>file`, `>&2`) is not one.
+ * `escape` is the shell's own escape character: a backslash in a POSIX shell,
+ * a backtick in PowerShell (where `C:\;` ends a command), a caret in cmd.
+ * Good enough to count and name the commands; not a shell parser.
+ */
+export function commandSegments(command, escape = "\\") {
+    const out = [];
+    let current = "";
+    let quote;
+    const push = () => {
+        const trimmed = current.trim();
+        if (trimmed)
+            out.push(trimmed);
+        current = "";
+    };
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (quote) {
+            current += ch;
+            if (ch === quote)
+                quote = undefined;
+            else if (ch === escape && quote === '"' && i + 1 < command.length)
+                current += command[++i];
+            continue;
+        }
+        if (ch === escape && i + 1 < command.length) {
+            current += ch + command[++i];
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            current += ch;
+            continue;
+        }
+        if (ch === "\n" || ch === "\r" || ch === ";") {
+            push();
+            continue;
+        }
+        if (ch === "|") {
+            push();
+            if (command[i + 1] === "|" || command[i + 1] === "&")
+                i += 1;
+            continue;
+        }
+        if (ch === "&") {
+            if (command[i + 1] === "&") {
+                push();
+                i += 1;
+                continue;
+            }
+            const prev = command[i - 1];
+            if (prev === ">" || prev === "<" || command[i + 1] === ">") {
+                current += ch;
+                continue;
+            }
+            push();
+            continue;
+        }
+        current += ch;
+    }
+    push();
+    return out;
+}
+/** Shells whose inline command (`-c`, `/c`, `-Command`) is itself a command line. */
+const SHELLS = new Set(["bash", "sh", "zsh", "dash", "ksh", "fish", "pwsh", "powershell", "cmd"]);
+/** The escape character of the shell `program` names (see {@link commandSegments}). */
+function escapeOf(program) {
+    if (program === "pwsh" || program === "powershell")
+        return "`";
+    if (program === "cmd")
+        return "^";
+    return "\\";
+}
+/** The words of one command, leading `NAME=value` assignments dropped. */
+function commandWords(segment) {
+    const parts = words(segment);
+    let i = 0;
+    while (i < parts.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(parts[i]))
+        i += 1;
+    return parts.slice(i);
+}
+/**
+ * What a command line does, command by command: the {@link commandHead} of
+ * each chained command, a shell's inline command expanded into its own, and a
+ * leading `cd <dir>` (which only says where) left out. Two command lines run
+ * the same things when these are equal.
+ */
+export function commandShape(command, depth = 0, escape = "\\") {
+    const segments = commandSegments(command, escape);
+    while (segments.length > 1) {
+        const first = (commandWords(segments[0])[0] ?? "").toLowerCase();
+        if (first !== "cd" && first !== "pushd" && first !== "set-location" && first !== "sl")
+            break;
+        segments.shift();
+    }
+    const out = [];
+    for (const segment of segments) {
+        const parts = commandWords(segment);
+        const program = programName(parts[0] ?? "");
+        const inline = SHELLS.has(program) ? parts.findIndex((a, i) => i > 0 && INLINE_FLAGS.has(a.toLowerCase())) : -1;
+        const inner = inline >= 0 ? parts.slice(inline + 1).join(" ").trim() : "";
+        if (inner && depth < MAX_HEAD_DEPTH) {
+            out.push(...commandShape(inner, depth + 1, escapeOf(program)));
+            continue;
+        }
+        out.push(commandHead(segment, depth));
+    }
+    return out;
+}
+/** Runs a command inside the command: `$(…)`, backticks, `<(…)`, `>(…)`. */
+const SUBSTITUTION = /\$\(|`|<\(|>\(/;
+/** PowerShell's: a subexpression, `$(…)` or `@(…)`, or a script block. */
+const PS_SUBSTITUTION = /\$\(|@\(|\{/;
+/** A shell command's verdict, for `Bash` or `PowerShell`. See the file comment. */
+function commandVerdict(mine, theirs, powershell = false) {
+    // No command at all: the model left it to the directive.
+    if (!mine)
+        return { ok: true };
+    if (mine.replace(/\s+/g, " ") === theirs.replace(/\s+/g, " "))
+        return { ok: true };
+    // What a substitution runs is not in any head: only an exact copy is the step.
+    if ((powershell ? PS_SUBSTITUTION : SUBSTITUTION).test(theirs)) {
+        return { ok: false, why: "the step runs a command substitution, and the call is not that command" };
+    }
+    const escape = powershell ? "`" : "\\";
+    const a = commandShape(mine, 0, escape);
+    const b = commandShape(theirs, 0, escape);
+    if (a.length === 0 || b.length === 0 || a.some((h) => !h) || b.some((h) => !h)) {
+        return { ok: false, why: `the call runs \`${a.join(" ; ") || "?"}\`, the step runs \`${b.join(" ; ") || "?"}\`` };
+    }
+    if (a.length !== b.length) {
+        return {
+            ok: false,
+            why: `the call runs ${a.length} command${a.length === 1 ? "" : "s"} (\`${a.join(" ; ")}\`), the step ${b.length} (\`${b.join(" ; ")}\`)`,
+        };
+    }
+    for (let i = 0; i < a.length; i += 1) {
+        if (a[i] !== b[i])
+            return { ok: false, why: `the call runs \`${a[i]}\`, the step runs \`${b[i]}\`` };
+    }
+    return { ok: true };
+}
+/** Statement verbs of SQL and its dialects: what a query does to the data. */
+const SQL_VERBS = new Set([
+    "SELECT", "INSERT", "UPDATE", "DELETE", "MERGE", "UPSERT", "REPLACE", "WITH", "VALUES", "TABLE",
+    "CREATE", "ALTER", "DROP", "TRUNCATE", "RENAME", "COMMENT", "GRANT", "REVOKE", "SET", "RESET",
+    "SHOW", "DESCRIBE", "DESC", "EXPLAIN", "ANALYZE", "VACUUM", "COPY", "CALL", "EXEC", "EXECUTE",
+    "DO", "BEGIN", "START", "COMMIT", "ROLLBACK", "SAVEPOINT", "RELEASE", "LOCK", "UNLOCK", "USE",
+    "PRAGMA", "ATTACH", "DETACH", "REINDEX", "CLUSTER", "REFRESH", "LOAD", "UNLOAD", "PUT", "GET",
+    "REMOVE", "LIST", "OPTIMIZE", "KILL", "HANDLER", "LISTEN", "NOTIFY", "PREPARE", "DEALLOCATE",
+    "DECLARE", "FETCH", "MOVE", "CLOSE", "CHECKPOINT", "DISCARD", "SECURITY", "IMPORT", "EXPORT",
+]);
+/** The verbs that make a string a statement, whatever its argument is called. */
+const SQL_DATA_VERBS = new Set([
+    "SELECT", "INSERT", "UPDATE", "DELETE", "MERGE", "UPSERT", "REPLACE", "WITH", "CREATE", "ALTER",
+    "DROP", "TRUNCATE", "GRANT", "REVOKE", "EXEC", "EXECUTE", "CALL", "COPY",
+]);
+/** Writes a `WITH` statement may end in: `WITH … DELETE` is a delete, not a read. */
+const SQL_WRITES = /\b(INSERT|UPDATE|DELETE|MERGE|UPSERT|REPLACE|DROP|TRUNCATE|ALTER|CREATE|GRANT|REVOKE)\b/gi;
+/** Words of an argument key that say its value is what a command-running tool runs. */
+const STATEMENT_WORDS = new Set([
+    "sql", "query", "statement", "statements", "stmt", "command", "cmd", "commands", "script", "code",
+    "q", "expression", "eval", "input", "shell", "exec", "execute",
+]);
+/** Whether an argument key names a statement: `sql`, `query`, `sqlQuery`, `shell_command`. */
+function isStatementKey(key) {
+    return key
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .some((word) => STATEMENT_WORDS.has(word));
+}
+/** SQL text with its comments blanked out. */
+function withoutSqlComments(text) {
+    return text.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
+}
+/**
+ * What a string argument of a command-running tool does: the verb of each SQL
+ * statement it holds (`SELECT ; DELETE`), or — not SQL — the commands it runs
+ * ({@link commandShape}). Undefined for something that is neither.
+ */
+function statementShape(value) {
+    const text = withoutSqlComments(value).trim();
+    if (!text)
+        return undefined;
+    const firstWord = /^\(*\s*([A-Za-z]+)/.exec(text)?.[1]?.toUpperCase();
+    if (firstWord && SQL_VERBS.has(firstWord)) {
+        // Statements end at `;`; `||` and `&` are operators in SQL, not chains.
+        const verbs = commandSegments(text.replace(/[\n\r|&]/g, " "))
+            .map((statement) => {
+            const body = statement.trim();
+            const verb = /^\(*\s*([A-Za-z]+)/.exec(body)?.[1]?.toUpperCase() ?? "?";
+            if (verb !== "WITH")
+                return verb;
+            const writes = [...new Set((body.match(SQL_WRITES) ?? []).map((w) => w.toUpperCase()))].sort();
+            return writes.length > 0 ? `WITH ${writes.join(" ")}` : "WITH";
+        })
+            .filter((v) => v !== "?");
+        return verbs.length > 0 ? verbs.join(" ; ") : undefined;
+    }
+    const shape = commandShape(value);
+    return shape.length > 0 && shape.every((h) => h) ? shape.join(" ; ") : undefined;
+}
+/**
+ * An MCP tool whose input is run (a query, a statement, a command): every
+ * statement-bearing argument of the step must be supplied by the model and do
+ * the same thing. See the file comment. Undefined when the step carries no
+ * such argument, and the ordinary rule decides.
+ */
+function statementVerdict(model, step) {
+    let checked = false;
+    for (const [key, theirs] of Object.entries(step)) {
+        if (typeof theirs !== "string")
+            continue;
+        const stepShape = statementShape(theirs);
+        // An empty `input` or `code` beside the query runs nothing: the model need
+        // not supply it. Unless the model's own runs something there — then its
+        // call is not the step (a pin would swap that for nothing).
+        if (!theirs.trim() && stepShape === undefined) {
+            const mine = model[key];
+            if (typeof mine === "string" && mine.trim() && isStatementKey(key)) {
+                return { ok: false, why: `its ${key} runs \`${statementShape(mine) ?? "?"}\`, the step's is empty` };
+            }
+            continue;
+        }
+        // Named a statement, or reading as a statement that reads or changes data
+        // whatever its name.
+        const bearing = isStatementKey(key) ||
+            (stepShape !== undefined && stepShape.split(" ; ").some((v) => SQL_DATA_VERBS.has(v.split(" ")[0])));
+        if (!bearing)
+            continue;
+        checked = true;
+        const mine = model[key];
+        if (typeof mine !== "string")
+            return { ok: false, why: `it does not supply the step's ${key}` };
+        if (mine.replace(/\s+/g, " ").trim() === theirs.replace(/\s+/g, " ").trim())
+            continue;
+        // A shell command's substitution runs what no head shows (backticks are
+        // only an identifier quote in SQL, so SQL is not held to this).
+        const sql = stepShape !== undefined && /^[A-Z]/.test(stepShape);
+        if (!sql && SUBSTITUTION.test(theirs)) {
+            return { ok: false, why: `the step's ${key} runs a command substitution, and the call's is not that command` };
+        }
+        const myShape = statementShape(mine);
+        if (!stepShape || !myShape || myShape !== stepShape) {
+            return { ok: false, why: `its ${key} runs \`${myShape ?? "?"}\`, the step's runs \`${stepShape ?? "?"}\`` };
+        }
+    }
+    return checked ? { ok: true } : undefined;
+}
+/**
+ * Whether the model's call `modelArgs` to `toolName` may be pinned to the
+ * step's `pinnedArgs`. See the file comment for the rule.
+ */
+export function pinCompatible(toolName, modelArgs, pinnedArgs) {
+    const model = record(modelArgs);
+    const step = record(pinnedArgs);
+    if (stableStringify(model) === stableStringify(step))
+        return { ok: true };
+    if (toolName === "Bash" || toolName === "PowerShell") {
+        const mine = typeof model.command === "string" ? model.command.trim() : "";
+        const theirs = typeof step.command === "string" ? step.command.trim() : "";
+        return commandVerdict(mine, theirs, toolName === "PowerShell");
+    }
+    const modelKeys = Object.keys(model);
+    if (modelKeys.length === 0)
+        return { ok: true };
+    if (sinkOf(toolName) === "command") {
+        const verdict = statementVerdict(model, step);
+        if (verdict && !verdict.ok)
+            return verdict;
+    }
+    for (const key of TARGET_KEYS) {
+        const mine = model[key];
+        const theirs = step[key];
+        if (typeof mine !== "string" || typeof theirs !== "string")
+            continue;
+        if (normalTarget(mine) === normalTarget(theirs))
+            continue;
+        if (READERS.has(toolName))
+            continue;
+        return { ok: false, why: `its ${key} is not the step's` };
+    }
+    if (FILE_WRITERS.has(toolName)) {
+        const mine = model.file_path ?? model.notebook_path;
+        const theirs = step.file_path ?? step.notebook_path;
+        if (typeof mine === "string" && typeof theirs !== "string") {
+            return { ok: false, why: "it writes a file the step does not name" };
+        }
+    }
+    const stepKeys = Object.keys(step);
+    if (stepKeys.length === 0)
+        return { ok: true };
+    return modelKeys.some((k) => stepKeys.includes(k))
+        ? { ok: true }
+        : { ok: false, why: "it shares no argument with the step" };
+}
+//# sourceMappingURL=pin-guard.js.map