brane 0.1.1 → 0.3.1

package/dist/memory/wordpiece.js

@@ -0,0 +1,247 @@
+/**
+ * A BERT WordPiece tokenizer, read straight from a HuggingFace `tokenizer.json`.
+ *
+ * This exists so brane can embed text without `@huggingface/transformers`,
+ * whose omnibus package drags in `onnxruntime-web` (91 MB) and `sharp` (whose
+ * libvips advisories are the only findings in a root `npm audit`) purely to
+ * support modalities and runtimes brane never uses. What brane actually needs
+ * from that package is this file plus one ONNX session.
+ *
+ * The implementation is a deliberate port of transformers.js's own
+ * `BertNormalizer`, `BertPreTokenizer` and `WordPieceTokenizer`, not an
+ * independent reading of the BERT paper. Token ids must match the previous
+ * pipeline *exactly*: `memory_vec` already holds vectors embedded the old way,
+ * and a tokenizer that disagrees on even a rare word doesn't fail — it quietly
+ * shifts query vectors away from the stored ones and degrades search in a way
+ * no error surfaces. `src/test/wordpiece.test.ts` pins the agreement.
+ */
+import { readFileSync } from "node:fs";
+/** Matches transformers.js's PUNCTUATION_REGEX (`src/tokenizers.js`): Unicode
+ *  punctuation plus the ASCII symbol ranges BERT also treats as punctuation. */
+const PUNCTUATION = "\\p{P}\\u0021-\\u002F\\u003A-\\u0040\\u005B-\\u0060\\u007B-\\u007E";
+/** CJK ranges that BERT surrounds with whitespace so each char is its own token. */
+function isChineseChar(cp) {
+    return ((cp >= 0x4e00 && cp <= 0x9fff) ||
+        (cp >= 0x3400 && cp <= 0x4dbf) ||
+        (cp >= 0x20000 && cp <= 0x2a6df) ||
+        (cp >= 0x2a700 && cp <= 0x2b73f) ||
+        (cp >= 0x2b740 && cp <= 0x2b81f) ||
+        (cp >= 0x2b820 && cp <= 0x2ceaf) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0x2f800 && cp <= 0x2fa1f));
+}
+/** Control characters, excluding the three whitespace ones BERT keeps. */
+const CONTROL_RE = /^\p{Cc}|\p{Cf}|\p{Co}|\p{Cs}$/u;
+function isControl(char) {
+    if (char === "\t" || char === "\n" || char === "\r")
+        return false;
+    return CONTROL_RE.test(char);
+}
+export class WordPieceTokenizer {
+    vocab;
+    unkToken;
+    prefix;
+    maxCharsPerWord;
+    norm;
+    preTokenizePattern;
+    addedPattern;
+    addedIds;
+    clsId;
+    sepId;
+    padId;
+    unkId;
+    /** Longest sequence the model's position embeddings cover, `[CLS]`/`[SEP]` included. */
+    modelMaxLength;
+    constructor(json, modelMaxLength = 512) {
+        if (json.model.type !== "WordPiece") {
+            throw new Error(`Unsupported tokenizer model: ${json.model.type}`);
+        }
+        if (json.normalizer?.type !== "BertNormalizer") {
+            throw new Error(`Unsupported normalizer: ${json.normalizer?.type}`);
+        }
+        if (json.pre_tokenizer?.type !== "BertPreTokenizer") {
+            throw new Error(`Unsupported pre-tokenizer: ${json.pre_tokenizer?.type}`);
+        }
+        this.vocab = new Map(Object.entries(json.model.vocab));
+        this.unkToken = json.model.unk_token;
+        const unkId = this.vocab.get(this.unkToken);
+        if (unkId === undefined)
+            throw new Error("unk_token missing from vocab");
+        this.unkId = unkId;
+        this.prefix = json.model.continuing_subword_prefix;
+        this.maxCharsPerWord = json.model.max_input_chars_per_word ?? 100;
+        this.norm = json.normalizer;
+        this.modelMaxLength = modelMaxLength;
+        // Equivalent to "strip whitespace, split on punctuation" — the same pattern
+        // transformers.js builds to match the Rust implementation.
+        this.preTokenizePattern = new RegExp(`[^\\s${PUNCTUATION}]+|[${PUNCTUATION}]`, "gu");
+        // Added tokens are matched against the *raw* text before normalization, so
+        // a literal "[CLS]" appearing in a narration tokenizes as the special token
+        // — matching the reference implementation rather than being lowercased into
+        // pieces. Longest-first so "[MASK]" can't be shadowed by a shorter entry.
+        const added = (json.added_tokens ?? []).slice().sort((a, b) => b.content.length - a.content.length);
+        this.addedIds = new Map(added.map((t) => [t.content, t.id]));
+        this.addedPattern = added.length
+            ? new RegExp(added.map((t) => escapeRegExp(t.content)).join("|"), "g")
+            : null;
+        this.clsId = this.requireId("[CLS]");
+        this.sepId = this.requireId("[SEP]");
+        this.padId = this.requireId("[PAD]");
+    }
+    /** Load from a HuggingFace `tokenizer.json` on disk. */
+    static fromFile(path, modelMaxLength = 512) {
+        return new WordPieceTokenizer(JSON.parse(readFileSync(path, "utf8")), modelMaxLength);
+    }
+    requireId(token) {
+        const id = this.addedIds.get(token) ?? this.vocab.get(token);
+        if (id === undefined)
+            throw new Error(`Required token missing: ${token}`);
+        return id;
+    }
+    /** BertNormalizer: clean → space out CJK → lowercase → strip accents. */
+    normalize(text) {
+        if (this.norm.clean_text) {
+            let out = "";
+            for (const char of text) {
+                const cp = char.codePointAt(0);
+                if (cp === 0 || cp === 0xfffd || isControl(char))
+                    continue;
+                out += /^\s$/.test(char) ? " " : char;
+            }
+            text = out;
+        }
+        if (this.norm.handle_chinese_chars) {
+            let out = "";
+            for (let i = 0; i < text.length; i++) {
+                const char = text[i];
+                out += isChineseChar(char.charCodeAt(0)) ? ` ${char} ` : char;
+            }
+            text = out;
+        }
+        if (this.norm.lowercase) {
+            text = text.toLowerCase();
+            // `strip_accents: null` means "follow lowercase" — only an explicit
+            // `false` disables it. bge-small-en-v1.5 ships null, so accents go.
+            if (this.norm.strip_accents !== false)
+                text = stripAccents(text);
+        }
+        else if (this.norm.strip_accents) {
+            text = stripAccents(text);
+        }
+        return text;
+    }
+    /** Greedy longest-match-first WordPiece over one pre-token. */
+    wordPiece(token) {
+        const chars = [...token];
+        if (chars.length > this.maxCharsPerWord)
+            return [this.unkToken];
+        const sub = [];
+        let start = 0;
+        while (start < chars.length) {
+            let end = chars.length;
+            let match = null;
+            while (start < end) {
+                const candidate = (start > 0 ? this.prefix : "") + chars.slice(start, end).join("");
+                if (this.vocab.has(candidate)) {
+                    match = candidate;
+                    break;
+                }
+                --end;
+            }
+            // A single unmatched piece makes the *whole* word unknown — not just the
+            // offending span. That is BERT's rule and dropping it would silently
+            // change ids for any word containing an unseen character.
+            if (match === null)
+                return [this.unkToken];
+            sub.push(match);
+            start = end;
+        }
+        return sub;
+    }
+    /** Text → vocabulary ids, without `[CLS]`/`[SEP]` and without truncation. */
+    tokenize(text) {
+        const ids = [];
+        const segments = this.addedPattern
+            ? splitKeepingDelimiters(text, this.addedPattern)
+            : [{ text, isAdded: false }];
+        for (const seg of segments) {
+            if (seg.isAdded) {
+                ids.push(this.addedIds.get(seg.text));
+                continue;
+            }
+            const normalized = this.normalize(seg.text);
+            const preTokens = normalized.trim().match(this.preTokenizePattern) ?? [];
+            for (const pre of preTokens) {
+                for (const piece of this.wordPiece(pre)) {
+                    ids.push(this.vocab.get(piece) ?? this.unkId);
+                }
+            }
+        }
+        return ids;
+    }
+    /**
+     * Encode one text the way the feature-extraction pipeline does: wrap in
+     * `[CLS]`/`[SEP]`, then truncate to the model's position-embedding limit.
+     *
+     * Order matters, and not in the way it first looks. The obvious reading —
+     * reserve two slots so a long text still ends in `[SEP]` — is *wrong* here,
+     * because HuggingFace truncates the already-post-processed sequence: an
+     * over-long text comes back 512 ids ending on an ordinary word, with the
+     * closing `[SEP]` cut off. Reserving room instead put `[SEP]` at index 511
+     * and disagreed with the reference on every text over the limit — 13% of
+     * this corpus, all of them long ones. Matching the reference is the whole
+     * point of this file, so the surprising behaviour is the correct one.
+     */
+    encode(text) {
+        const ids = this.tokenize(text);
+        let input_ids = [this.clsId, ...ids, this.sepId];
+        if (input_ids.length > this.modelMaxLength) {
+            input_ids = input_ids.slice(0, this.modelMaxLength);
+        }
+        return {
+            input_ids,
+            attention_mask: new Array(input_ids.length).fill(1),
+            token_type_ids: new Array(input_ids.length).fill(0),
+        };
+    }
+    /**
+     * Encode a batch, right-padding to the longest member. Padding positions get
+     * `attention_mask: 0` so mean pooling ignores them — a batch must produce the
+     * same vector for a text as encoding it alone would.
+     */
+    encodeBatch(texts) {
+        const encodings = texts.map((t) => this.encode(t));
+        const width = encodings.reduce((m, e) => Math.max(m, e.input_ids.length), 0);
+        const pad = (row, fill) => [
+            ...row,
+            ...new Array(width - row.length).fill(fill),
+        ];
+        return {
+            input_ids: encodings.map((e) => pad(e.input_ids, this.padId)),
+            attention_mask: encodings.map((e) => pad(e.attention_mask, 0)),
+            token_type_ids: encodings.map((e) => pad(e.token_type_ids, 0)),
+        };
+    }
+}
+/** "Mark, Nonspacing" removal after NFD — BERT's accent stripping. */
+function stripAccents(text) {
+    return text.normalize("NFD").replace(/\p{Mn}/gu, "");
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function splitKeepingDelimiters(text, pattern) {
+    const out = [];
+    let last = 0;
+    pattern.lastIndex = 0;
+    for (let m = pattern.exec(text); m !== null; m = pattern.exec(text)) {
+        if (m.index > last)
+            out.push({ text: text.slice(last, m.index), isAdded: false });
+        out.push({ text: m[0], isAdded: true });
+        last = m.index + m[0].length;
+    }
+    if (last < text.length)
+        out.push({ text: text.slice(last), isAdded: false });
+    return out;
+}
+//# sourceMappingURL=wordpiece.js.map

package/dist/mentions-scan.js

@@ -0,0 +1,40 @@
+/** Extracting mentions from markdown, daemon-side.
+ *
+ *  This is the renderer with its output thrown away. It parses with the same
+ *  two extensions the app installs (`expo/components/Markdown.tsx`) and walks
+ *  the tree with the same spec (`shared/markdown-mentions.ts`), so a handle
+ *  fires a notification *iff* the operator would have seen it as a link.
+ *
+ *  The alternative — a regex over the raw `content` — is the parallel scanner
+ *  `docs/rendering-warnings.md` forbids for exactly this reason. Its failure is silent and
+ *  unexplainable: a pasted log containing `@claude-4c7289d1` inside a fenced
+ *  block shows as inert code in the UI while waking an agent, with nothing
+ *  visible to say why.
+ *
+ *  Lives here rather than in `shared/` because it imports `mdast-util-*`, and
+ *  metro resolves a shared module's dependencies from its own directory — see
+ *  `docs/math.md` on the `katex` alias. The daemon is the only caller.
+ */
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmAutolinkLiteral } from "micromark-extension-gfm-autolink-literal";
+import { gfmAutolinkLiteralFromMarkdown } from "mdast-util-gfm-autolink-literal";
+import { linkifyRefs } from "./shared/markdown-refs.js";
+import { collectMentionSpec } from "./shared/markdown-mentions.js";
+/** The narrative ids mentioned in `md`, in first-appearance order.
+ *
+ *  `isKnown` is what keeps a handle that names no narrative inert — the same
+ *  refusal `narrativeIdLinks` makes, so invented ids never become ledger rows.
+ *  Repeats collapse: the set is the dedup within one event, the table's UNIQUE
+ *  constraint is the dedup across re-scans. */
+export function extractMentions(md, isKnown) {
+    if (!md.includes("@"))
+        return [];
+    const found = new Set();
+    const tree = fromMarkdown(md, {
+        extensions: [gfmAutolinkLiteral()],
+        mdastExtensions: [gfmAutolinkLiteralFromMarkdown()],
+    });
+    linkifyRefs(tree, collectMentionSpec(isKnown, found));
+    return [...found];
+}
+//# sourceMappingURL=mentions-scan.js.map

package/dist/presence.js

@@ -0,0 +1,259 @@
+/**
+ * Confirm that the operator is at this machine, using the OS's own
+ * owner-authentication prompt — never one of ours.
+ *
+ * This is the human-presence check passkey enrollment rests on: a software
+ * authenticator can mint a passkey whose "user verified" flag is set with no
+ * human anywhere, and without attestation the daemon cannot tell it from
+ * Face ID. What an agent running as the operator cannot do is answer a
+ * system dialog that wants a fingerprint or the login password, so the first
+ * enrollment (and recovery) is confirmed here instead.
+ *
+ * Each platform runs a tool the OS already ships, so there is no native
+ * dependency:
+ *
+ * | platform      | tool                                 | asks for                      |
+ * |---------------|--------------------------------------|-------------------------------|
+ * | macOS         | `osascript` → LocalAuthentication    | Touch ID, Watch, or password  |
+ * | Windows / WSL | `powershell.exe` → Windows Hello     | face, fingerprint, or PIN     |
+ * | Linux desktop | `pkcheck` → polkit (`auth_self`)     | the user's own password       |
+ *
+ * Headless Linux has no dialog to show and reports `unavailable`; a hardware
+ * key is the answer there, not a password typed into a terminal an agent can
+ * also read.
+ *
+ * Every command is a fixed absolute path into a system directory, never a
+ * bare name looked up on the daemon's inherited PATH (or a path built from
+ * its environment), where a careless agent's PATH tweak could put a fake
+ * `osascript` that prints `{"ok":true}`. That is hygiene, not a defence: a
+ * hostile process running as the operator can already edit `dist/` or the
+ * database, which brane accepts as out of scope.
+ *
+ * Each backend is a pure `PresencePlan` (command, arguments, how to read the
+ * answer) so the suite checks every platform's plan on any platform without
+ * putting a dialog on anyone's screen. Only the macOS plan has been run
+ * against a real prompt.
+ */
+import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
+/** The polkit action the Linux backend checks; its policy is in docs/presence.md. */
+export const POLKIT_ACTION = "dev.brane.confirm-presence";
+export function detectPresencePlatform(platform = process.platform, procVersion = () => readFileSync("/proc/version", "utf8"), env = process.env) {
+    if (platform === "darwin")
+        return "macos";
+    if (platform === "win32")
+        return "windows";
+    if (platform !== "linux")
+        return "unsupported";
+    if (env.WSL_DISTRO_NAME)
+        return "wsl";
+    try {
+        if (/microsoft/i.test(procVersion()))
+            return "wsl";
+    }
+    catch {
+        // no /proc: not WSL
+    }
+    return "linux";
+}
+// ── macOS ──────────────────────────────────────────────────────────────
+/**
+ * JavaScript for Automation, run by `osascript -l JavaScript`. Policy 2 is
+ * `LAPolicyDeviceOwnerAuthentication`: biometrics, a paired Watch, or the
+ * login password — the dialog has no approve button of its own, so a
+ * synthetic click can cancel it but never pass it. The reply arrives on a
+ * callback, so the script spins the run loop until it does.
+ */
+export const MAC_SCRIPT = `
+ObjC.import('LocalAuthentication');
+ObjC.import('Foundation');
+function run(argv) {
+  const ctx = $.LAContext.alloc.init;
+  const canErr = Ref();
+  if (!ctx.canEvaluatePolicyError(2, canErr)) {
+    return JSON.stringify({ ok: false, unavailable: true, error: ObjC.unwrap(canErr[0].localizedDescription) });
+  }
+  let done = false, result = null;
+  ctx.evaluatePolicyLocalizedReasonReply(2, argv[0], (success, error) => {
+    result = success ? { ok: true } : { ok: false, code: Number(error.code), error: ObjC.unwrap(error.localizedDescription) };
+    done = true;
+  });
+  while (!done) $.NSRunLoop.currentRunLoop.runUntilDate($.NSDate.dateWithTimeIntervalSinceNow(0.1));
+  return JSON.stringify(result);
+}
+`;
+/**
+ * LAError codes that mean the operator said no. Not `systemCancel` (-4: the
+ * system took the dialog away) and not `authenticationFailed` (-1: too many
+ * wrong attempts) — both are `failed`, as `RetriesExhausted` is on Windows.
+ */
+const LA_CANCELED = new Set([-2 /* userCancel */]);
+export function macPlan(reason) {
+    const method = "macos-local-auth";
+    return {
+        method,
+        command: "/usr/bin/osascript",
+        args: ["-l", "JavaScript", "-e", MAC_SCRIPT, reason],
+        interpret(stdout, stderr, code) {
+            let r;
+            try {
+                r = JSON.parse(stdout.trim());
+            }
+            catch {
+                return { ok: false, method, reason: "failed", detail: (stderr || stdout).trim() || `exit ${code}` };
+            }
+            if (r.ok === true)
+                return { ok: true, method };
+            if (r.unavailable)
+                return { ok: false, method, reason: "unavailable", detail: r.error };
+            const canceled = typeof r.code === "number" && LA_CANCELED.has(r.code);
+            return { ok: false, method, reason: canceled ? "canceled" : "failed", detail: r.error };
+        },
+    };
+}
+// ── Windows and WSL ────────────────────────────────────────────────────
+/** A PowerShell single-quoted literal: only `'` is special, and it doubles. */
+function psQuote(s) {
+    return `'${s.replace(/'/g, "''")}'`;
+}
+/**
+ * Windows Hello through `UserConsentVerifier`, from Windows PowerShell 5.1
+ * (`powershell.exe`; PowerShell 7 dropped the WinRT projection). From WSL
+ * the same file is reachable through `/mnt/c`, and the prompt appears on
+ * the Windows desktop, out of reach of anything inside the Linux VM.
+ */
+export function windowsScript(reason) {
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        "Add-Type -AssemblyName System.Runtime.WindowsRuntime",
+        "$null = [Windows.Security.Credentials.UI.UserConsentVerifier,Windows.Security.Credentials.UI,ContentType=WindowsRuntime]",
+        "$asTask = [System.WindowsRuntimeSystemExtensions].GetMethods() | Where-Object { $_.Name -eq 'AsTask' -and $_.GetParameters().Count -eq 1 -and $_.GetParameters()[0].ParameterType.Name -eq 'IAsyncOperation`1' } | Select-Object -First 1",
+        "function Await($op, $type) { $t = $asTask.MakeGenericMethod($type).Invoke($null, @($op)); $null = $t.Wait(-1); $t.Result }",
+        "$avail = Await ([Windows.Security.Credentials.UI.UserConsentVerifier]::CheckAvailabilityAsync()) ([Windows.Security.Credentials.UI.UserConsentVerifierAvailability])",
+        "if ($avail -ne 'Available') { Write-Output \"unavailable:$avail\"; exit 0 }",
+        `$r = Await ([Windows.Security.Credentials.UI.UserConsentVerifier]::RequestVerificationAsync(${psQuote(reason)})) ([Windows.Security.Credentials.UI.UserConsentVerificationResult])`,
+        "Write-Output \"result:$r\"",
+    ].join("\n");
+}
+export function windowsPlan(reason, platform = "windows") {
+    const method = "windows-hello";
+    // Hard-coded, not built from %SystemRoot%: the daemon inherits its
+    // environment, so a path read from it is only as fixed as PATH is.
+    const command = platform === "wsl" ? WSL_POWERSHELL : WINDOWS_POWERSHELL;
+    // -EncodedCommand takes UTF-16LE base64, which sidesteps every layer of
+    // quoting between here, WSL's interop, and the Windows command line.
+    const encoded = Buffer.from(windowsScript(reason), "utf16le").toString("base64");
+    return {
+        method,
+        command,
+        args: ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded],
+        interpret(stdout, stderr, code) {
+            const line = stdout.trim().split(/\r?\n/).pop() ?? "";
+            if (line === "result:Verified")
+                return { ok: true, method };
+            if (line.startsWith("unavailable:")) {
+                return { ok: false, method, reason: "unavailable", detail: line.slice("unavailable:".length) };
+            }
+            if (line === "result:Canceled") {
+                return { ok: false, method, reason: "canceled", detail: line.slice("result:".length) };
+            }
+            if (line.startsWith("result:"))
+                return { ok: false, method, reason: "failed", detail: line.slice("result:".length) };
+            return { ok: false, method, reason: "failed", detail: (stderr || stdout).trim() || `exit ${code}` };
+        },
+    };
+}
+// ── Linux ──────────────────────────────────────────────────────────────
+/**
+ * polkit, against brane's own action. Its policy (in docs/presence.md)
+ * says `auth_self` — the user proves they are themselves, not an admin —
+ * with no retention, so every check asks. polkit's built-in actions mostly
+ * want an administrator, which is the wrong question, hence the file.
+ *
+ * pkcheck exit codes (pkcheck(1)): 0 authorized; 1 not authorized, which
+ * includes a daemon outside an active local session (over SSH, under a
+ * service manager), where polkit never asks; 2 a challenge but no agent to
+ * show it (headless); 3 dismissed, the only one that means the operator said
+ * no; 127 error, which is how an unregistered action is believed to surface
+ * (untested), so the message is matched before the code.
+ */
+export function linuxPlan(pid = process.pid) {
+    const method = "polkit";
+    return {
+        method,
+        command: "/usr/bin/pkcheck",
+        args: ["--action-id", POLKIT_ACTION, "--process", String(pid), "--allow-user-interaction"],
+        interpret(stdout, stderr, code) {
+            const detail = (stderr || stdout).trim() || undefined;
+            if (code === 0)
+                return { ok: true, method };
+            if (/not registered|No action with action id/i.test(detail ?? "")) {
+                return { ok: false, method, reason: "unavailable", detail: `polkit action ${POLKIT_ACTION} is not installed` };
+            }
+            if (code === 3)
+                return { ok: false, method, reason: "canceled", detail };
+            if (code === 2)
+                return { ok: false, method, reason: "unavailable", detail: detail ?? "no polkit agent (headless?)" };
+            return { ok: false, method, reason: "failed", detail: detail ?? `exit ${code}` };
+        },
+    };
+}
+/** Windows PowerShell 5.1 where Windows installs it. */
+export const WINDOWS_POWERSHELL = "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe";
+/** The same file as WSL's default automount sees it. */
+export const WSL_POWERSHELL = "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe";
+// ── Dispatch ───────────────────────────────────────────────────────────
+export function presencePlan(reason, platform = detectPresencePlatform()) {
+    switch (platform) {
+        case "macos":
+            return macPlan(reason);
+        case "windows":
+        case "wsl":
+            return windowsPlan(reason, platform);
+        case "linux":
+            return linuxPlan();
+        default:
+            return null;
+    }
+}
+/**
+ * Ask the operator to confirm they are here. `reason` is shown in the
+ * prompt where the platform allows it (macOS, Windows); polkit shows its
+ * policy's fixed message. Never throws.
+ */
+export function confirmPresence(reason, opts = {}) {
+    const plan = presencePlan(reason, opts.platform);
+    if (!plan)
+        return Promise.resolve({ ok: false, method: null, reason: "unavailable", detail: process.platform });
+    return runPlan(plan, opts.timeoutMs ?? 120_000, opts.signal);
+}
+/** Run a plan's command and hand its outcome to the plan. Aborting `signal`
+ *  kills the helper, which takes its dialog down with it on macOS (see
+ *  docs/presence.md for Windows). Never throws. */
+export function runPlan(plan, timeoutMs, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve({ ok: false, method: plan.method, reason: "aborted" });
+            return;
+        }
+        execFile(plan.command, plan.args, { timeout: timeoutMs, maxBuffer: 1024 * 1024, windowsHide: true, signal }, (err, stdout, stderr) => {
+            const e = err;
+            if (e?.name === "AbortError") {
+                resolve({ ok: false, method: plan.method, reason: "aborted" });
+            }
+            else if (e?.code === "ENOENT") {
+                resolve({ ok: false, method: plan.method, reason: "unavailable", detail: `${plan.command} not found` });
+            }
+            else if (e?.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+                resolve({ ok: false, method: plan.method, reason: "failed", detail: "output too large" });
+            }
+            else if (e?.killed) {
+                resolve({ ok: false, method: plan.method, reason: "timeout" });
+            }
+            else {
+                resolve(plan.interpret(String(stdout), String(stderr), typeof e?.code === "number" ? e.code : e ? null : 0));
+            }
+        });
+    });
+}
+//# sourceMappingURL=presence.js.map