@general-liquidity/sharpebench 0.0.3

package/README.md

@@ -0,0 +1,51 @@
+# @general-liquidity/sharpebench
+
+**The luck-robust scoring kernel for AI trading agents.**
+
+Rank agents on risk-adjusted *skill that survives deflation* — not the luckiest run over one quarter. This is the **identical Rust kernel** that powers the [SharpeBench](https://github.com/general-liquidity/sharpebench) benchmark, compiled to WebAssembly, with a typed JS/TS API. No native add-on, no network — pure deterministic scoring.
+
+```bash
+npm install @general-liquidity/sharpebench
+```
+
+## Quickstart
+
+```ts
+import { score, greeks, selfAudit } from "@general-liquidity/sharpebench";
+
+// Rank a field. Raw return is reported but is NEVER the rank key — an agent ranks
+// only if its edge survives deflation, pass^k reliability, and process discipline.
+const board = score([
+  { agent_id: "skilled", runs: [{ returns: [0.002, 0.0021, 0.0019, 0.002] }] },
+  { agent_id: "lucky",   runs: [{ returns: [0.05, 0, 0, 0] }] },
+]);
+console.log(board[0].agent_id, board[0].deflated_sharpe, board[0].rank_eligible);
+
+// Prove the scorer resists known gaming attacks.
+console.log(selfAudit().all_defended); // true
+
+// Options tail-risk: a short-gamma position a linear Sharpe can't see.
+console.log(greeks({ spot: 100, strike: 100, t_years: 1, rate: 0.05, vol: 0.2, is_call: true }).price);
+```
+
+## API
+
+| Function | Returns |
+|---|---|
+| `score(submissions, config?)` | ranked `CompositeScore[]` |
+| `scoreAgent(submission, config?)` | one `CompositeScore` (deflated Sharpe, pass^k, process, rolling worst-case Sharpe) |
+| `selfAudit()` | `SelfAuditReport` — the benchmark's anti-gaming proof |
+| `auditBriefing(briefing, policy?)` | `BriefingAudit` — input-side salience-bias audit |
+| `scoreAllocation(trajectory, policy?)` | `AllocationReport` — weight-vector validity + L1 turnover |
+| `greeks(params)` | `GreeksResult` — Black-Scholes price + Greeks + tail-selling risk |
+| `canary(seed)` | `Canary` — a do-not-train contamination tripwire |
+
+All inputs and outputs are fully typed (TypeScript declarations ship with the package). The kernel is deterministic: the same input yields byte-identical scores on any platform.
+
+## Why luck-robust?
+
+Most agent leaderboards rank a raw Sharpe over a single short window — so they mostly measure noise. SharpeBench adds, as **ranking gates**: deflated Sharpe / PSR, pass^k reliability (clear the bar on *every* seed × window), field-wide significance, and process discipline (an order that skipped the risk gate zeroes the entry). See the [benchmark repo](https://github.com/general-liquidity/sharpebench) for the full methodology.
+
+## License
+
+MIT OR Apache-2.0, at your option.

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import type { AgentSubmission, AllocationPolicy, AllocationReport, AllocationTrajectory, Briefing, BriefingAudit, BriefingPolicy, Canary, CompositeScore, GreeksParams, GreeksResult, ScoreConfig, SelfAuditReport } from "./types.js";
+export * from "./types.js";
+/**
+ * Score and rank a field of submissions on the luck-robust composite. Returns the
+ * leaderboard (rank-eligible agents first); raw return is reported but never the
+ * rank key.
+ */
+export declare function score(submissions: AgentSubmission[], config?: ScoreConfig): CompositeScore[];
+/**
+ * Score a single submission → one {@link CompositeScore} carrying its deflated
+ * Sharpe, pass^k verdict, process score, rolling worst-case Sharpe, and the rest.
+ */
+export declare function scoreAgent(submission: AgentSubmission, config?: ScoreConfig): CompositeScore;
+/** Fire the known gaming attacks at the scorer and report whether each is demoted. */
+export declare function selfAudit(): SelfAuditReport;
+/** Audit a shared briefing for input-side salience bias. */
+export declare function auditBriefing(briefing: Briefing, policy?: BriefingPolicy): BriefingAudit;
+/** Score a target-allocation trajectory: weight validity + L1 turnover. */
+export declare function scoreAllocation(trajectory: AllocationTrajectory, policy?: AllocationPolicy): AllocationReport;
+/** Black-Scholes price + Greeks + tail-selling (short-gamma/vega) classification. */
+export declare function greeks(params: GreeksParams): GreeksResult;
+/** Derive a deterministic do-not-train contamination tripwire from seed material. */
+export declare function canary(seed: string): Canary;

package/dist/index.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.score = score;
+exports.scoreAgent = scoreAgent;
+exports.selfAudit = selfAudit;
+exports.auditBriefing = auditBriefing;
+exports.scoreAllocation = scoreAllocation;
+exports.greeks = greeks;
+exports.canary = canary;
+/**
+ * `@general-liquidity/sharpebench` — the luck-robust scoring kernel for AI trading
+ * agents, as a typed JS API over the *identical* Rust kernel that powers the
+ * SharpeBench benchmark (compiled to WebAssembly).
+ *
+ * An agent does not rank on raw return. It ranks only if its edge survives
+ * deflation for the number of trials, reliability across every seed × window
+ * (pass^k), and decision-process discipline. See {@link score}.
+ */
+const kernel = __importStar(require("../pkg/sharpebench.js"));
+__exportStar(require("./types.js"), exports);
+/** Parse a kernel JSON string, surfacing the kernel's `{error}` as a thrown Error. */
+function parse(json) {
+    const value = JSON.parse(json);
+    if (value && typeof value === "object" && "error" in value) {
+        throw new Error(String(value.error));
+    }
+    return value;
+}
+/** Empty/absent config → `""`, which the kernel reads as "use defaults". */
+function optJson(value) {
+    if (!value || Object.keys(value).length === 0)
+        return "";
+    return JSON.stringify(value);
+}
+/**
+ * Score and rank a field of submissions on the luck-robust composite. Returns the
+ * leaderboard (rank-eligible agents first); raw return is reported but never the
+ * rank key.
+ */
+function score(submissions, config) {
+    return parse(kernel.score(JSON.stringify(submissions), optJson(config)));
+}
+/**
+ * Score a single submission → one {@link CompositeScore} carrying its deflated
+ * Sharpe, pass^k verdict, process score, rolling worst-case Sharpe, and the rest.
+ */
+function scoreAgent(submission, config) {
+    return parse(kernel.score_agent(JSON.stringify(submission), optJson(config)));
+}
+/** Fire the known gaming attacks at the scorer and report whether each is demoted. */
+function selfAudit() {
+    return parse(kernel.self_audit());
+}
+/** Audit a shared briefing for input-side salience bias. */
+function auditBriefing(briefing, policy) {
+    return parse(kernel.audit_briefing(JSON.stringify(briefing), optJson(policy)));
+}
+/** Score a target-allocation trajectory: weight validity + L1 turnover. */
+function scoreAllocation(trajectory, policy) {
+    return parse(kernel.score_allocation(JSON.stringify(trajectory), optJson(policy)));
+}
+/** Black-Scholes price + Greeks + tail-selling (short-gamma/vega) classification. */
+function greeks(params) {
+    return parse(kernel.greeks(JSON.stringify(params)));
+}
+/** Derive a deterministic do-not-train contamination tripwire from seed material. */
+function canary(seed) {
+    return parse(kernel.canary(seed));
+}

package/dist/types.d.ts

@@ -0,0 +1,128 @@
+/** One per-seed × per-window return series + (optional) decision trace/costs. */
+export interface Run {
+    returns: number[];
+    cost?: number;
+    confidences?: number[];
+    outcomes?: number[];
+    trace?: {
+        events: unknown[];
+    };
+}
+/** An agent's full submission: its runs across seeds × windows. */
+export interface AgentSubmission {
+    agent_id: string;
+    runs: Run[];
+    /** The agent's own declared in-sample trials (deflated against). */
+    in_sample_trials?: number;
+    /** Candidate return series from the agent's own selection search. */
+    candidates?: number[][];
+}
+/** Scoring configuration. Omit (or pass `{}`) to use the luck-robust defaults. */
+export interface ScoreConfig {
+    n_trials?: number;
+    rolling_window?: number;
+    [k: string]: unknown;
+}
+/** A scored agent. Raw return is reported but is never the rank key. */
+export interface CompositeScore {
+    agent_id: string;
+    deflated_sharpe: number;
+    passed_k: boolean;
+    process_ok: boolean;
+    rank_eligible: boolean;
+    raw_mean_return: number;
+    [k: string]: unknown;
+}
+export interface SelfAuditReport {
+    cases: Array<{
+        name: string;
+        attack: string;
+        defended: boolean;
+        detail: string;
+    }>;
+    all_defended: boolean;
+}
+export type RowKind = "fact" | "uncertainty" | "counterpoint";
+export interface BriefingRow {
+    text: string;
+    kind: RowKind;
+}
+export interface BriefingSection {
+    asset_area: string;
+    rows: BriefingRow[];
+}
+export type TableOrdering = "option_order" | "performance" | "unspecified";
+export interface ReturnTable {
+    ordering: TableOrdering;
+    entries: Array<{
+        label: string;
+        trailing_return: number;
+    }>;
+}
+export interface Briefing {
+    sections: BriefingSection[];
+    return_table?: ReturnTable | null;
+}
+export interface BriefingPolicy {
+    max_rows_per_area?: number;
+    require_counterbalance?: boolean;
+    require_option_order_sort?: boolean;
+    max_area_salience?: number;
+}
+export interface BriefingAudit {
+    balanced: boolean;
+    violations: unknown[];
+    salience: Array<{
+        asset_area: string;
+        row_count: number;
+        salience: number;
+    }>;
+}
+export interface AllocationStep {
+    weights: number[];
+}
+export interface AllocationTrajectory {
+    steps: AllocationStep[];
+}
+export interface AllocationPolicy {
+    allow_shorts?: boolean;
+    max_gross?: number;
+    epsilon?: number;
+}
+export interface AllocationReport {
+    total_turnover: number;
+    mean_turnover: number;
+    weight_violations: unknown[];
+    valid: boolean;
+}
+export interface GreeksParams {
+    spot: number;
+    strike: number;
+    t_years: number;
+    rate: number;
+    vol: number;
+    is_call: boolean;
+}
+export interface Greeks {
+    delta: number;
+    gamma: number;
+    theta: number;
+    vega: number;
+    rho: number;
+}
+export interface GreeksRisk {
+    naked_short_gamma: boolean;
+    unbounded_tail: boolean;
+    short_vega: boolean;
+    net_gamma: number;
+    net_vega: number;
+}
+export interface GreeksResult {
+    price: number;
+    greeks: Greeks;
+    risk: GreeksRisk;
+}
+export interface Canary {
+    id: string;
+    token: string;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+// Typed views of the SharpeBench kernel's JSON shapes. Inputs are typed precisely;
+// report outputs carry the headline fields plus an index signature, so they stay
+// forward-compatible as the kernel adds reported axes.
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@general-liquidity/sharpebench",
+  "version": "0.0.3",
+  "description": "The luck-robust scoring kernel for AI trading agents — deflated Sharpe, pass^k reliability, and process-discipline gates. The identical Rust kernel as the SharpeBench benchmark, compiled to WASM.",
+  "keywords": [
+    "trading",
+    "benchmark",
+    "sharpe-ratio",
+    "deflated-sharpe",
+    "quant",
+    "ai-agents",
+    "backtesting",
+    "wasm"
+  ],
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/general-liquidity/sharpebench.git",
+    "directory": "npm"
+  },
+  "homepage": "https://github.com/general-liquidity/sharpebench#readme",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "pkg"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test",
+    "prepublishOnly": "tsc"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/pkg/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "sharpebench-wasm",
+  "description": "WASM bindings for the SharpeBench scoring kernel (consumed by Gordon/Bun via the identical kernel).",
+  "version": "0.0.3",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/general-liquidity/sharpebench"
+  },
+  "files": [
+    "sharpebench_bg.wasm",
+    "sharpebench.js",
+    "sharpebench.d.ts"
+  ],
+  "main": "sharpebench.js",
+  "types": "sharpebench.d.ts"
+}

package/pkg/sharpebench.d.ts

@@ -0,0 +1,16 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function audit_briefing(briefing_json: string, policy_json: string): string;
+
+export function canary(seed: string): string;
+
+export function greeks(params_json: string): string;
+
+export function score(submissions_json: string, config_json: string): string;
+
+export function score_agent(submission_json: string, config_json: string): string;
+
+export function score_allocation(trajectory_json: string, policy_json: string): string;
+
+export function self_audit(): string;

package/pkg/sharpebench.js

@@ -0,0 +1,245 @@
+/* @ts-self-types="./sharpebench.d.ts" */
+
+/**
+ * @param {string} briefing_json
+ * @param {string} policy_json
+ * @returns {string}
+ */
+function audit_briefing(briefing_json, policy_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(briefing_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(policy_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.audit_briefing(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.audit_briefing = audit_briefing;
+
+/**
+ * @param {string} seed
+ * @returns {string}
+ */
+function canary(seed) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.canary(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.canary = canary;
+
+/**
+ * @param {string} params_json
+ * @returns {string}
+ */
+function greeks(params_json) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(params_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.greeks(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.greeks = greeks;
+
+/**
+ * @param {string} submissions_json
+ * @param {string} config_json
+ * @returns {string}
+ */
+function score(submissions_json, config_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(submissions_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(config_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.score(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.score = score;
+
+/**
+ * @param {string} submission_json
+ * @param {string} config_json
+ * @returns {string}
+ */
+function score_agent(submission_json, config_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(submission_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(config_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.score_agent(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.score_agent = score_agent;
+
+/**
+ * @param {string} trajectory_json
+ * @param {string} policy_json
+ * @returns {string}
+ */
+function score_allocation(trajectory_json, policy_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(trajectory_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(policy_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.score_allocation(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.score_allocation = score_allocation;
+
+/**
+ * @returns {string}
+ */
+function self_audit() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.self_audit();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.self_audit = self_audit;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./sharpebench_bg.js": import0,
+    };
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/sharpebench_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
+wasm.__wbindgen_start();

package/pkg/sharpebench_bg.wasm.d.ts

@@ -0,0 +1,15 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const audit_briefing: (a: number, b: number, c: number, d: number) => [number, number];
+export const canary: (a: number, b: number) => [number, number];
+export const greeks: (a: number, b: number) => [number, number];
+export const score: (a: number, b: number, c: number, d: number) => [number, number];
+export const score_agent: (a: number, b: number, c: number, d: number) => [number, number];
+export const score_allocation: (a: number, b: number, c: number, d: number) => [number, number];
+export const self_audit: () => [number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;