omnis-key 0.1.0__tar.gz

omnis_key-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+graft omnis_key/engine

omnis_key-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: omnis-key
+Version: 0.1.0
+Summary: OMNIS KEY — JourdanLabs' local-first, receipt-backed engineering workbench (VANTAGE, CADMUS, PROSPECTOR, LUNA), runnable from a pip install.
+Author: JourdanLabs
+License: UNLICENSED
+Project-URL: Homepage, https://github.com/jourdanlabs/omnis
+Keywords: omnis,code-audit,verification,governed,jourdanlabs
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# omnis-key
+
+**OMNIS KEY** — JourdanLabs' local-first, receipt-backed engineering workbench,
+runnable from a `pip install`.
+
+OMNIS runs entirely on your machine. Its deterministic engines —
+**VANTAGE** (code audit), **CADMUS** (spec creation), **PROSPECTOR** (estate
+discovery), and **LUNA** (persistent, receipt-backed memory) — are governed by
+the **BIFROST** gate and a hash-chained **LUNA** ledger, so every action carries
+an auditable receipt. *Receipts over fluency.*
+
+## Why pip
+
+This package exists so OMNIS can be procured and vetted through the standard
+Python supply chain (`pip install`) in environments that prefer it. The engine
+is bundled as audited JavaScript and launched through a local Node.js runtime.
+
+## Install
+
+```bash
+pip install omnis-key
+```
+
+**Requires Node.js ≥ 18** on your `PATH` (https://nodejs.org). The wheel bundles
+the OMNIS engine; Node runs it locally — nothing is sent off the machine unless
+you explicitly configure a cloud model lane.
+
+## Run
+
+```bash
+omnis                 # full workbench; agents can use cloud LLMs if keys are set
+omnis --lockdown      # air-gapped: every cloud model lane is refused (data can't leave)
+omnis --no-agents     # workbench only: deterministic tools, no agent chamber
+omnis --port 8790 --data-dir ~/.omnis/workspace
+```
+
+`omnis` starts a local server on `127.0.0.1` and opens the workbench in your
+browser. Workspace data + the LUNA ledger live under `~/.omnis/` by default.
+
+## Air-gapped / regulated environments
+
+`--lockdown` disables **every** network model lane at the adapter call site (not
+just a status flag), leaving the local and manual lanes only. The deterministic
+workbench works fully offline. Combine with `--no-agents` for a pure,
+no-model-lanes build.
+
+## Build from source
+
+```bash
+# from the repo root
+npm run build                              # build the engine
+npm --prefix desktop/renderer run build    # build the UI (optional)
+pypi/build_wheel.sh                         # bundle engine + build wheel/sdist
+pip install pypi/dist/omnis_key-*.whl
+```
+
+Publishing to PyPI (`twine upload dist/*`) requires a JourdanLabs PyPI API token.
+
+🐦‍⬛ + 🔑

omnis_key-0.1.0/README.md

@@ -0,0 +1,59 @@
+# omnis-key
+
+**OMNIS KEY** — JourdanLabs' local-first, receipt-backed engineering workbench,
+runnable from a `pip install`.
+
+OMNIS runs entirely on your machine. Its deterministic engines —
+**VANTAGE** (code audit), **CADMUS** (spec creation), **PROSPECTOR** (estate
+discovery), and **LUNA** (persistent, receipt-backed memory) — are governed by
+the **BIFROST** gate and a hash-chained **LUNA** ledger, so every action carries
+an auditable receipt. *Receipts over fluency.*
+
+## Why pip
+
+This package exists so OMNIS can be procured and vetted through the standard
+Python supply chain (`pip install`) in environments that prefer it. The engine
+is bundled as audited JavaScript and launched through a local Node.js runtime.
+
+## Install
+
+```bash
+pip install omnis-key
+```
+
+**Requires Node.js ≥ 18** on your `PATH` (https://nodejs.org). The wheel bundles
+the OMNIS engine; Node runs it locally — nothing is sent off the machine unless
+you explicitly configure a cloud model lane.
+
+## Run
+
+```bash
+omnis                 # full workbench; agents can use cloud LLMs if keys are set
+omnis --lockdown      # air-gapped: every cloud model lane is refused (data can't leave)
+omnis --no-agents     # workbench only: deterministic tools, no agent chamber
+omnis --port 8790 --data-dir ~/.omnis/workspace
+```
+
+`omnis` starts a local server on `127.0.0.1` and opens the workbench in your
+browser. Workspace data + the LUNA ledger live under `~/.omnis/` by default.
+
+## Air-gapped / regulated environments
+
+`--lockdown` disables **every** network model lane at the adapter call site (not
+just a status flag), leaving the local and manual lanes only. The deterministic
+workbench works fully offline. Combine with `--no-agents` for a pure,
+no-model-lanes build.
+
+## Build from source
+
+```bash
+# from the repo root
+npm run build                              # build the engine
+npm --prefix desktop/renderer run build    # build the UI (optional)
+pypi/build_wheel.sh                         # bundle engine + build wheel/sdist
+pip install pypi/dist/omnis_key-*.whl
+```
+
+Publishing to PyPI (`twine upload dist/*`) requires a JourdanLabs PyPI API token.
+
+🐦‍⬛ + 🔑

omnis_key-0.1.0/omnis_key/__init__.py

@@ -0,0 +1,9 @@
+"""OMNIS KEY — local-first, receipt-backed engineering workbench (pip-installable).
+
+The deterministic engine (VANTAGE / CADMUS / PROSPECTOR / LUNA, the BIFROST gate,
+and the LUNA hash-chained ledger) is bundled as JavaScript under ``engine/`` and
+launched through a local Node.js runtime. ``omnis`` (the console entry point)
+starts the local server and opens the workbench in your browser.
+"""
+
+__version__ = "0.1.0"

omnis_key-0.1.0/omnis_key/cli.py

@@ -0,0 +1,104 @@
+"""Console launcher for OMNIS KEY.
+
+Finds a local Node.js runtime, starts the bundled OMNIS engine on a local port,
+and opens the workbench. Flags mirror the desktop builds:
+
+  omnis                 cloud-capable (agents can call cloud LLMs if keys are set)
+  omnis --lockdown      air-gapped: every network model lane is refused
+  omnis --no-agents     workbench only: no agent chamber, deterministic tools only
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import socket
+import subprocess
+import sys
+import time
+import webbrowser
+from pathlib import Path
+
+ENGINE_DIR = Path(__file__).resolve().parent / "engine"
+
+
+def _find_node() -> str:
+    node = shutil.which("node")
+    if not node:
+        sys.exit(
+            "OMNIS requires Node.js (>= 18) on your PATH.\n"
+            "Install it from https://nodejs.org and run `omnis` again."
+        )
+    return node
+
+
+def _free_port(preferred: int = 8790) -> int:
+    port = preferred
+    while True:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            if sock.connect_ex(("127.0.0.1", port)) != 0:
+                return port
+        port += 1
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="omnis", description="OMNIS KEY — local engineering workbench.")
+    parser.add_argument("--port", type=int, default=0, help="port to serve on (0 = auto-pick)")
+    parser.add_argument(
+        "--data-dir",
+        default=str(Path.home() / ".omnis" / "workspace"),
+        help="where the workspace + LUNA ledger live",
+    )
+    parser.add_argument("--lockdown", action="store_true", help="air-gapped: disable all cloud model lanes")
+    parser.add_argument("--no-agents", action="store_true", help="workbench only: hide the agent chamber")
+    parser.add_argument("--no-browser", action="store_true", help="do not open a browser window")
+    args = parser.parse_args()
+
+    node = _find_node()
+    cli_js = ENGINE_DIR / "dist" / "src" / "cli.js"
+    if not cli_js.exists():
+        sys.exit(
+            f"OMNIS engine not found at {cli_js}.\n"
+            "This wheel was built without the engine bundled (run pypi/build_wheel.sh)."
+        )
+
+    data_dir = Path(args.data_dir).expanduser()
+    data_dir.mkdir(parents=True, exist_ok=True)
+    port = args.port or _free_port()
+
+    env = dict(os.environ)
+    if args.lockdown:
+        env["OMNIS_LOCKDOWN"] = "1"
+    if args.no_agents:
+        env["OMNIS_NO_AGENTS"] = "1"
+
+    ui_dir = ENGINE_DIR / "ui"
+    open_path = "/desktop"
+    if (ui_dir / "index.html").exists():
+        env["OMNIS_UI_DIR"] = str(ui_dir)
+        open_path = "/"
+
+    url = f"http://127.0.0.1:{port}{open_path}"
+    print(f"OMNIS KEY → {url}   (data: {data_dir})")
+    if args.lockdown:
+        print("  mode: air-gapped (cloud model lanes disabled)")
+    if args.no_agents:
+        print("  mode: workbench (no agent chamber)")
+
+    proc = subprocess.Popen(
+        [node, str(cli_js), "omnis", "app", str(data_dir), str(port)],
+        cwd=str(ENGINE_DIR),
+        env=env,
+    )
+    try:
+        if not args.no_browser:
+            time.sleep(1.5)
+            webbrowser.open(url)
+        proc.wait()
+    except KeyboardInterrupt:
+        proc.terminate()
+
+
+if __name__ == "__main__":
+    main()

omnis_key-0.1.0/omnis_key/engine/dist/src/audit/artifact.d.ts

@@ -0,0 +1,2 @@
+import type { FinalOutput } from "../types.js";
+export declare function attachAuditHash(output: Omit<FinalOutput, "audit_hash">): FinalOutput;

omnis_key-0.1.0/omnis_key/engine/dist/src/audit/artifact.js

@@ -0,0 +1,7 @@
+import { hashCanonical } from "./hash.js";
+export function attachAuditHash(output) {
+    return {
+        ...output,
+        audit_hash: hashCanonical(output)
+    };
+}

omnis_key-0.1.0/omnis_key/engine/dist/src/audit/canonicalize.d.ts

@@ -0,0 +1,3 @@
+export declare function canonicalize(value: unknown): string;
+export declare function sortValue(value: unknown): unknown;
+export declare function canonicalJson(value: unknown): string;

omnis_key-0.1.0/omnis_key/engine/dist/src/audit/canonicalize.js

@@ -0,0 +1,23 @@
+export function canonicalize(value) {
+    return JSON.stringify(sortValue(value));
+}
+export function sortValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortValue);
+    }
+    if (value !== null && typeof value === "object") {
+        const input = value;
+        const output = {};
+        for (const key of Object.keys(input).sort()) {
+            const item = input[key];
+            if (item !== undefined) {
+                output[key] = sortValue(item);
+            }
+        }
+        return output;
+    }
+    return value;
+}
+export function canonicalJson(value) {
+    return `${JSON.stringify(sortValue(value), null, 2)}\n`;
+}

omnis_key-0.1.0/omnis_key/engine/dist/src/audit/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function hashCanonical(value: unknown): string;
+export declare function shortHash(value: unknown): string;

omnis_key-0.1.0/omnis_key/engine/dist/src/audit/hash.js

@@ -0,0 +1,8 @@
+import { createHash } from "node:crypto";
+import { canonicalize } from "./canonicalize.js";
+export function hashCanonical(value) {
+    return createHash("sha256").update(canonicalize(value)).digest("hex");
+}
+export function shortHash(value) {
+    return hashCanonical(value).slice(0, 12);
+}

omnis_key-0.1.0/omnis_key/engine/dist/src/baseline/matchFirst.d.ts

@@ -0,0 +1,2 @@
+import type { BaselineOutput, MirrorverseInput } from "../types.js";
+export declare function runMatchFirstBaseline(input: MirrorverseInput): BaselineOutput;

omnis_key-0.1.0/omnis_key/engine/dist/src/baseline/matchFirst.js

@@ -0,0 +1,76 @@
+import { attachBaselineHash } from "./util.js";
+const STOPWORDS = new Set(["a", "an", "and", "as", "at", "by", "for", "from", "in", "is", "of", "on", "or", "the", "to", "with"]);
+export function runMatchFirstBaseline(input) {
+    if (!Array.isArray(input.records) || input.records.length === 0) {
+        return attachBaselineHash({
+            status: "ABSTAIN",
+            selected_signature: null,
+            support_packet_ids: [],
+            reasons: ["no_records"],
+            overlap_score: 0
+        });
+    }
+    const records = [...input.records].sort((a, b) => `${a.source_id}:${a.timestamp}:${a.text}`.localeCompare(`${b.source_id}:${b.timestamp}:${b.text}`));
+    const identifiers = records.map((record) => extractIdentifier(record.text)).filter((value) => value !== null);
+    const names = records.map((record) => extractName(record.text)).filter((value) => value !== null);
+    const commonIdentifier = mostCommon(identifiers);
+    const commonName = mostCommon(names);
+    const overlap = averagePairwiseOverlap(records.map((record) => terms(record.text)));
+    const support_packet_ids = records.map((_, index) => `packet_${String(index + 1).padStart(3, "0")}`);
+    const reasons = [];
+    if (commonIdentifier) {
+        reasons.push(`identifier_agreement:${commonIdentifier}`);
+    }
+    if (commonName) {
+        reasons.push(`name_anchor:${commonName}`);
+    }
+    reasons.push(`token_overlap:${overlap.toFixed(3)}`);
+    const approve = (commonIdentifier !== null && support_packet_ids.length >= 2) || (commonName !== null && overlap >= 0.58);
+    return attachBaselineHash({
+        status: approve ? "APPROVED" : "ABSTAIN",
+        selected_signature: commonName && commonIdentifier ? `${commonName}#${commonIdentifier}` : commonName ?? commonIdentifier,
+        support_packet_ids: approve ? support_packet_ids : [],
+        reasons,
+        overlap_score: Number(overlap.toFixed(6))
+    });
+}
+function extractIdentifier(text) {
+    return text.match(/\b(?:identifier|id|ein|ssn|parcel_id|property_id)\s*[:=]\s*([A-Za-z0-9._-]+)/i)?.[1]?.toLowerCase() ?? null;
+}
+function extractName(text) {
+    return (text
+        .match(/\b(?:entity|name|company|person|property)\s*[:=]\s*([^;,\n]+)/i)?.[1]
+        ?.trim()
+        .toLowerCase()
+        .replace(/\s+/g, " ") ?? null);
+}
+function terms(text) {
+    const values = text.toLowerCase().match(/[a-z0-9][a-z0-9._-]*/g) ?? [];
+    return new Set(values.filter((value) => value.length > 1 && !STOPWORDS.has(value)));
+}
+function averagePairwiseOverlap(termSets) {
+    if (termSets.length < 2) {
+        return termSets.length === 1 ? 1 : 0;
+    }
+    const scores = [];
+    for (let left = 0; left < termSets.length; left += 1) {
+        for (let right = left + 1; right < termSets.length; right += 1) {
+            const leftSet = termSets[left];
+            const rightSet = termSets[right];
+            if (!leftSet || !rightSet) {
+                continue;
+            }
+            const intersection = [...leftSet].filter((term) => rightSet.has(term)).length;
+            const union = new Set([...leftSet, ...rightSet]).size;
+            scores.push(union === 0 ? 0 : intersection / union);
+        }
+    }
+    return scores.reduce((sum, score) => sum + score, 0) / scores.length;
+}
+function mostCommon(values) {
+    const counts = new Map();
+    for (const value of values) {
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    }
+    return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0]?.[0] ?? null;
+}

omnis_key-0.1.0/omnis_key/engine/dist/src/baseline/util.d.ts

@@ -0,0 +1,2 @@
+import type { BaselineOutput } from "../types.js";
+export declare function attachBaselineHash(output: Omit<BaselineOutput, "audit_hash">): BaselineOutput;

omnis_key-0.1.0/omnis_key/engine/dist/src/baseline/util.js

@@ -0,0 +1,7 @@
+import { hashCanonical } from "../audit/hash.js";
+export function attachBaselineHash(output) {
+    return {
+        ...output,
+        audit_hash: hashCanonical(output)
+    };
+}

omnis_key-0.1.0/omnis_key/engine/dist/src/benchmark/cases.d.ts

@@ -0,0 +1,2 @@
+import type { BenchmarkCase } from "../types.js";
+export declare const DEFAULT_BENCHMARK_CASES: BenchmarkCase[];

omnis_key-0.1.0/omnis_key/engine/dist/src/benchmark/cases.js

@@ -0,0 +1,56 @@
+export const DEFAULT_BENCHMARK_CASES = [
+    {
+        case_id: "clean_approval",
+        fixture: "simple-match.json",
+        expectation: "mirrorverse_should_approve",
+        description: "Two independent sources agree without disqualifiers."
+    },
+    {
+        case_id: "status_trap",
+        fixture: "match-first-trap.json",
+        expectation: "mirrorverse_should_reject",
+        description: "Strong identifier match hides mutually exclusive status claims."
+    },
+    {
+        case_id: "duplicate_origin_laundering",
+        fixture: "duplicate-laundering.json",
+        expectation: "mirrorverse_should_block",
+        description: "Two surface sources share one explicit origin lineage."
+    },
+    {
+        case_id: "fingerprint_laundering",
+        fixture: "fingerprint-laundering.json",
+        expectation: "mirrorverse_should_block",
+        description: "Two copied packets omit origin metadata but share claim/text fingerprints."
+    },
+    {
+        case_id: "numeric_conflict",
+        fixture: "numeric-conflict.json",
+        expectation: "mirrorverse_should_reject",
+        description: "Identity agreement hides incompatible numeric claims."
+    },
+    {
+        case_id: "numeric_tolerance_brittle",
+        fixture: "numeric-tolerance-brittle.json",
+        expectation: "mirrorverse_should_block",
+        description: "Candidate survives STATIC only because numeric tolerance is permissive."
+    },
+    {
+        case_id: "parallax_shadow",
+        fixture: "parallax-shadow.json",
+        expectation: "mirrorverse_should_block",
+        description: "Certified winner has a wounded same-name material-signature shadow."
+    },
+    {
+        case_id: "stale_evidence",
+        fixture: "stale-evidence.json",
+        expectation: "mirrorverse_should_block",
+        description: "Otherwise valid proof is stale at decision time."
+    },
+    {
+        case_id: "predicate_stale_claim",
+        fixture: "predicate-stale-claim.json",
+        expectation: "mirrorverse_should_block",
+        description: "Packet is globally fresh, but a predicate-specific claim half-life has expired."
+    }
+];

omnis_key-0.1.0/omnis_key/engine/dist/src/benchmark/enterpriseTrust.d.ts

@@ -0,0 +1,3 @@
+import type { EnterpriseTrustBenchmarkReport, EnterpriseTrustCase } from "../types.js";
+export declare const ENTERPRISE_TRUST_CASES: EnterpriseTrustCase[];
+export declare function runEnterpriseTrustBenchmark(fixturesRoot: string): EnterpriseTrustBenchmarkReport;

omnis_key-0.1.0/omnis_key/engine/dist/src/benchmark/enterpriseTrust.js

@@ -0,0 +1,128 @@
+import { join } from "node:path";
+import { readFileSync } from "node:fs";
+import { hashCanonical, shortHash } from "../audit/hash.js";
+import { runFinal } from "../pipeline.js";
+export const ENTERPRISE_TRUST_CASES = [
+    {
+        case_id: "clean_enterprise_approval",
+        fixture: "simple-match.json",
+        workflow: "knowledge",
+        risk: "low",
+        expected_gate: "APPROVED",
+        failure_mode: "none",
+        description: "Clean multi-source evidence should release."
+    },
+    {
+        case_id: "audit_identifier_conflict",
+        fixture: "contradiction.json",
+        workflow: "audit",
+        risk: "critical",
+        expected_gate: "REJECTED",
+        failure_mode: "contradiction",
+        description: "Conflicting identifiers should block an audit conclusion."
+    },
+    {
+        case_id: "finance_ambiguous_counterparties",
+        fixture: "ambiguous-survivors.json",
+        workflow: "finance",
+        risk: "high",
+        expected_gate: "ABSTAIN",
+        failure_mode: "ambiguity",
+        description: "Incompatible surviving entities should force abstention."
+    },
+    {
+        case_id: "migration_brittle_keystone",
+        fixture: "brittle-evidence.json",
+        workflow: "migration",
+        risk: "high",
+        expected_gate: "ABSTAIN",
+        failure_mode: "brittle_evidence",
+        description: "A migration answer that collapses when one source is removed should not ship."
+    },
+    {
+        case_id: "knowledge_stale_claim",
+        fixture: "stale-evidence.json",
+        workflow: "knowledge",
+        risk: "medium",
+        expected_gate: "ABSTAIN",
+        failure_mode: "stale_evidence",
+        description: "Expired support should block release."
+    },
+    {
+        case_id: "audit_laundered_sources",
+        fixture: "duplicate-laundering.json",
+        workflow: "audit",
+        risk: "high",
+        expected_gate: "ABSTAIN",
+        failure_mode: "laundered_evidence",
+        description: "Two citations with one origin should not satisfy independent proof."
+    },
+    {
+        case_id: "finance_source_priority_conflict",
+        fixture: "source-priority-conflict.json",
+        workflow: "finance",
+        risk: "high",
+        expected_gate: "ABSTAIN",
+        failure_mode: "priority_conflict",
+        description: "Official and lower-priority classifications in conflict should block release."
+    }
+];
+export function runEnterpriseTrustBenchmark(fixturesRoot) {
+    const results = ENTERPRISE_TRUST_CASES.map((benchmarkCase) => runEnterpriseTrustCase(fixturesRoot, benchmarkCase));
+    const summary = {
+        total_cases: results.length,
+        clarion_wins: results.filter((result) => result.outcome === "clarion_win").length,
+        baseline_ties: results.filter((result) => result.outcome === "baseline_tie").length,
+        clarion_needs_work: results.filter((result) => result.outcome === "clarion_needs_work").length,
+        blocked_risky_cases: results.filter((result) => result.expected_gate !== "APPROVED" && result.clarion_status !== "APPROVED").length,
+        approved_clean_cases: results.filter((result) => result.expected_gate === "APPROVED" && result.clarion_status === "APPROVED").length
+    };
+    const withoutHash = {
+        run_id: `enterprise_trust_${shortHash({ fixturesRoot, results, summary })}`,
+        fixtures_root: fixturesRoot,
+        results,
+        summary
+    };
+    return {
+        ...withoutHash,
+        audit_hash: hashCanonical(withoutHash)
+    };
+}
+function runEnterpriseTrustCase(fixturesRoot, benchmarkCase) {
+    const input = JSON.parse(readFileSync(join(fixturesRoot, benchmarkCase.fixture), "utf8"));
+    const final = runFinal(input);
+    const outcome = classify(benchmarkCase, final.status);
+    return {
+        case_id: benchmarkCase.case_id,
+        fixture: benchmarkCase.fixture,
+        workflow: benchmarkCase.workflow,
+        risk: benchmarkCase.risk,
+        expected_gate: benchmarkCase.expected_gate,
+        clarion_status: final.status,
+        fluent_baseline_status: "APPROVED",
+        outcome,
+        lesson: lessonFor(benchmarkCase, final.status, outcome),
+        proof_packet_count: final.proof_packet_ids.length,
+        veto_count: final.veto_summary.length,
+        uncertainty_count: final.uncertainty_summary.length,
+        clarion_audit_hash: final.audit_hash
+    };
+}
+function classify(benchmarkCase, status) {
+    if (status === benchmarkCase.expected_gate && status === "APPROVED") {
+        return "baseline_tie";
+    }
+    if (status === benchmarkCase.expected_gate) {
+        return "clarion_win";
+    }
+    return "clarion_needs_work";
+}
+function lessonFor(benchmarkCase, status, outcome) {
+    if (outcome === "clarion_win") {
+        return `CLARION blocked fluent enterprise release for ${benchmarkCase.failure_mode}: ${benchmarkCase.description}`;
+    }
+    if (outcome === "baseline_tie") {
+        return `Clean evidence released: ${benchmarkCase.description}`;
+    }
+    return `Inspect gate doctrine: expected ${benchmarkCase.expected_gate}, got ${status}; ${benchmarkCase.description}`;
+}

omnis_key-0.1.0/omnis_key/engine/dist/src/benchmark/run.d.ts

@@ -0,0 +1,3 @@
+import type { BenchmarkCase, BenchmarkReport, BenchmarkResult } from "../types.js";
+export declare function runBenchmark(fixturesDir: string, cases?: BenchmarkCase[]): BenchmarkReport;
+export declare function runBenchmarkCase(fixturesDir: string, benchmarkCase: BenchmarkCase): BenchmarkResult;