@taifoon/jev 0.1.0 → 0.2.1

package/dist/ask.d.ts

@@ -1,16 +1,13 @@
 import type { Answer, Question } from './rubric.js';
-export declare const TRIAL_URL = "https://typesafe.taifoon.dev/v1/trial";
 export declare const TYPESAFE_URL = "https://api.typesafe.ai";
-export declare const TRIAL_MAX_STATE = 4000;
+/** The model every key-path call asks for. Pinned, not `jev-latest`: a record says which model answered, and an alias can move. */
+export declare const JEV_MODEL = "jev-1.13.0";
 export type Asked = {
     answers: Record<string, Answer>;
     model: string | null;
     latency_ms: number | null;
-    connection: 'trial' | 'key';
-    trial: {
-        calls: number;
-        left: number;
-    } | null;
+    connection: 'key';
+    trial: null;
 };
 export declare class JevError extends Error {
     readonly status: number;
@@ -21,7 +18,7 @@ export declare function askJev(a: {
     text: string;
     questions: readonly Question[];
     key?: string | null;
-    trialUrl?: string;
     endpoint?: string;
+    model?: string;
     fetch?: typeof fetch;
 }): Promise<Asked>;

package/dist/ask.js

@@ -1,6 +1,6 @@
-export const TRIAL_URL = 'https://typesafe.taifoon.dev/v1/trial';
 export const TYPESAFE_URL = 'https://api.typesafe.ai';
-export const TRIAL_MAX_STATE = 4_000;
+/** The model every key-path call asks for. Pinned, not `jev-latest`: a record says which model answered, and an alias can move. */
+export const JEV_MODEL = 'jev-1.13.0';
 export class JevError extends Error {
     status;
     next;
@@ -15,33 +15,21 @@ const norm = (id, a) => ({ id, value: String(a.value ?? a.choice ?? ''), confide
 export async function askJev(a) {
     const f = a.fetch ?? fetch;
     const started = Date.now();
-    if (a.key) {
-        const base = (a.endpoint ?? TYPESAFE_URL).replace(/\/$/, '');
-        if (!/^https:\/\//.test(base))
-            throw new JevError('a key is only sent over https', 400);
-        const questions = Object.fromEntries(a.questions.map((q) => [q.id, { type: 'choice', instructions: q.text, criteria: Object.fromEntries(q.options.map((o) => [o, o])) }]));
-        const r = await f(`${base}/v1/systemone`, { method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${a.key}` }, body: JSON.stringify({ model: 'jev-latest', state: a.text, questions }), signal: AbortSignal.timeout(65_000) });
-        const j = (await r.json().catch(() => ({})));
-        if (!r.ok)
-            throw new JevError(`TypeSafe answered ${r.status}${r.status === 401 || r.status === 403 ? ': the key was rejected' : r.status === 402 ? ': the account has no credit' : ''}`, r.status);
-        const answers = {};
-        for (const q of a.questions) {
-            const x = j.answers?.[q.id];
-            if (x)
-                answers[q.id] = norm(q.id, x);
-        }
-        return { answers, model: j.model ?? null, latency_ms: Date.now() - started, connection: 'key', trial: null };
-    }
-    const body = { state: a.text, questions: a.questions.map((q) => ({ id: q.id, kind: 'choice', text: q.text, options: [...q.options] })) };
-    const r = await f(a.trialUrl ?? TRIAL_URL, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(65_000) });
+    if (!a.key)
+        throw new JevError('a TypeSafe key is required: get one at console.typesafe.ai and pass { key }', 400, 'grade({ key: process.env.TYPESAFE_KEY })');
+    const base = (a.endpoint ?? TYPESAFE_URL).replace(/\/$/, '');
+    if (!/^https:\/\//.test(base))
+        throw new JevError('a key is only sent over https', 400);
+    const questions = Object.fromEntries(a.questions.map((q) => [q.id, { type: 'choice', instructions: q.text, criteria: Object.fromEntries(q.options.map((o) => [o, o])) }]));
+    const r = await f(`${base}/v1/systemone`, { method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${a.key}` }, body: JSON.stringify({ model: a.model ?? JEV_MODEL, state: a.text, questions }), signal: AbortSignal.timeout(65_000) });
     const j = (await r.json().catch(() => ({})));
-    if (!r.ok || j.ok === false)
-        throw new JevError(`the free trial answered ${r.status}: ${j.error ?? 'refused'}`, r.status, j.next ?? 'use your own TypeSafe key: grade({ key })');
+    if (!r.ok)
+        throw new JevError(`TypeSafe answered ${r.status}${r.status === 401 || r.status === 403 ? ': the key was rejected' : r.status === 402 ? ': the account has no credit' : ''}`, r.status);
     const answers = {};
-    for (const x of j.answers ?? []) {
-        const id = String(x.id ?? '');
-        if (id && x.schema_ok !== false)
-            answers[id] = norm(id, x);
+    for (const q of a.questions) {
+        const x = j.answers?.[q.id];
+        if (x)
+            answers[q.id] = norm(q.id, x);
     }
-    return { answers, model: j.upstreamModel ?? j.model ?? null, latency_ms: typeof j.latency_ms === 'number' ? j.latency_ms : Date.now() - started, connection: 'trial', trial: j.trial ? { calls: j.trial.calls, left: j.trial.left } : null };
+    return { answers, model: j.model ?? null, latency_ms: Date.now() - started, connection: 'key', trial: null };
 }

package/dist/contracts.d.ts

@@ -17,18 +17,22 @@ export declare const CONTRACTS: Readonly<{
         readonly judgeAdapter: "0xbd4c9e797a8DBbfdde9C77bc5A5b21ACf611Db8f";
         readonly assuranceHook: "0x7110c8951d17b69054395742e265bbd98259564a";
     };
-    /** Base (8453). answerLog / decisionLog: null in this version → record({ network: 'base' }) returns the call data with `to: null` */
+    /** Base (8453): both logs are live. Only the KMS recorder 0xe9F0E71e7Fc66864126C0aE5588a7858b25dE51D is `trusted` on the answer log. */
     readonly base: {
         readonly chainId: 8453;
         readonly rpc: "https://mainnet.base.org";
+        /** JevAnswerLog, redeployed 2026-09-27 (tx 0xeb7d2dac…ae87); supersedes 0x5bac70eb78224bbCBa83f5A36DF09D549d3f57fa */
         readonly answerLog: {
             address: string;
             fromBlock: number;
         } | null;
+        /** JevDecisionLog, deployed 2026-09-27 (tx 0x0e6300c0…4fc7); the recorder is msg.sender */
         readonly decisionLog: {
             address: string;
             fromBlock: number;
         } | null;
+        /** the one trusted recorder of the Base answer log */
+        readonly answerRecorder: "0xe9F0E71e7Fc66864126C0aE5588a7858b25dE51D";
         readonly virtualsErc8183: "0x238E541BfefD82238730D00a2208E5497F1832E0";
         readonly virtualsMemoAcpRouter: "0xa6C9BA866992cfD7fd6460ba912bfa405adA9df0";
         readonly bitagentErc8183: "0x5009ABB3A309115a4a682C66BAf3BC9E0329BaB7";

package/dist/contracts.js

@@ -13,12 +13,16 @@ export const CONTRACTS = Object.freeze({
         judgeAdapter: '0xbd4c9e797a8DBbfdde9C77bc5A5b21ACf611Db8f',
         assuranceHook: '0x7110c8951d17b69054395742e265bbd98259564a',
     },
-    /** Base (8453). answerLog / decisionLog: null in this version → record({ network: 'base' }) returns the call data with `to: null` */
+    /** Base (8453): both logs are live. Only the KMS recorder 0xe9F0E71e7Fc66864126C0aE5588a7858b25dE51D is `trusted` on the answer log. */
     base: {
         chainId: 8453,
         rpc: 'https://mainnet.base.org',
-        answerLog: null,
-        decisionLog: null,
+        /** JevAnswerLog, redeployed 2026-09-27 (tx 0xeb7d2dac…ae87); supersedes 0x5bac70eb78224bbCBa83f5A36DF09D549d3f57fa */
+        answerLog: { address: '0x8e9B9cE86a2d55c10318607b0c815B7B8C66254d', fromBlock: 51_863_008 },
+        /** JevDecisionLog, deployed 2026-09-27 (tx 0x0e6300c0…4fc7); the recorder is msg.sender */
+        decisionLog: { address: '0x209490d6A0FFC5368A42b0c2208BDCda853f6a92', fromBlock: 51_856_200 },
+        /** the one trusted recorder of the Base answer log */
+        answerRecorder: '0xe9F0E71e7Fc66864126C0aE5588a7858b25dE51D',
         virtualsErc8183: '0x238E541BfefD82238730D00a2208E5497F1832E0',
         virtualsMemoAcpRouter: '0xa6C9BA866992cfD7fd6460ba912bfa405adA9df0',
         bitagentErc8183: '0x5009ABB3A309115a4a682C66BAf3BC9E0329BaB7',

package/dist/grade.d.ts

@@ -12,10 +12,6 @@ export type GradeInput = {
     rubric?: Rubric | RubricInput;
     /** your own TypeSafe key → api.typesafe.ai. Never stored, never recorded. */
     key?: string | null;
-    /** no key: the public trial (3 free calls). `true` or { url } */
-    trial?: boolean | {
-        url?: string;
-    };
     /** answers you already have (e.g. from the n8n TypeSafe node): nothing is asked, the rest is identical */
     answers?: Record<string, Answer> | Answer[];
     /** the model that produced supplied answers, e.g. "jev-1.13.0" */

package/dist/grade.js

@@ -1,11 +1,10 @@
 // grade(): evidence → deterministic facts → Jev's atomic questions → composed verdict → receipt.
-import { askJev, JevError, TRIAL_MAX_STATE } from './ask.js';
+import { askJev, JevError } from './ask.js';
 import { answersOf, buildReceipt, DEFAULT_FACTS, inputFor, packOf, rubricOf } from './receipt.js';
 export async function grade(g) {
     const rubric = rubricOf(g.rubric);
     const facts = (await g.facts) ?? DEFAULT_FACTS;
-    const useTrial = Boolean(!g.key && !g.answers && g.trial);
-    const { state, jevState } = inputFor(packOf(g.evidence), facts, useTrial ? TRIAL_MAX_STATE : undefined);
+    const { state, jevState } = inputFor(packOf(g.evidence), facts);
     // the facts decide first: a hard fail is final and Jev is never asked
     let asked = null;
     let answers = null;
@@ -18,9 +17,9 @@ export async function grade(g) {
             connection = 'supplied';
         }
         else {
-            if (!g.key && !g.trial)
-                throw new JevError('pass { key } (your TypeSafe key) or { trial: true } (3 free calls)', 400);
-            asked = await askJev({ text: jevState, questions: rubric.asked, key: g.key, trialUrl: typeof g.trial === 'object' ? g.trial.url : undefined, endpoint: g.endpoint, fetch: g.fetch });
+            if (!g.key)
+                throw new JevError('pass { key } (your TypeSafe key, from console.typesafe.ai) or { answers } you already have', 400);
+            asked = await askJev({ text: jevState, questions: rubric.asked, key: g.key, endpoint: g.endpoint, fetch: g.fetch });
             const missing = rubric.asked.filter((q) => !asked.answers[q.id]).map((q) => q.id);
             if (missing.length)
                 throw new JevError(`Jev returned no valid answer for: ${missing.join(', ')}`, 502);

package/dist/index.d.ts

@@ -1,25 +1,30 @@
 /**
  * @taifoon/jev — Jev as a grader any protocol can call.
  *
+ *   prepareJob()     an agent job as the buyer laid it out → the evidence Jev reads + the code checks
  *   grade()          evidence → deterministic facts → Jev's atomic questions → composed verdict → receipt
  *   facts()          the deterministic checks a protocol supplies (a failed one is final; Jev is not asked)
  *   record()         the unsigned calls that put the receipt's digests on JevAnswerLog / JevDecisionLog
  *   evaluatorCall()  the unsigned call that ends the job on the protocol whose evaluator seat you hold
  *   verify()         recompute every digest and find the chain events that hold them
+ *   pipeline()       one job through the coordination layer's steps: pick → evidence → facts → grade → record → evaluator → premium → verify
  *   RUBRIC_v1        the questions, thresholds and composition (pass your own rubric to grade)
  *   CONTRACTS        where the logs and the evaluator seats are
  *
- * No runtime dependency. No key inside: the free trial, or your own TypeSafe key.
+ * No runtime dependency. No key inside: Jev is called with your own TypeSafe key (console.typesafe.ai).
  */
 export { grade } from './grade.js';
 export { facts } from './facts.js';
+export { prepareJob, runCheck } from './job.js';
 export { record } from './record.js';
 export { evaluatorCall } from './evaluator/index.js';
 export { verify } from './verify.js';
+export { pipeline, STEPS, LAYER, factsFromEvidence, protocolFor, parseJob } from './pipeline.js';
 export { RUBRIC_v1 } from './rubric.js';
 export { CONTRACTS } from './contracts.js';
 export type { GradeInput, Receipt } from './grade.js';
 export type { FactsInput, Check } from './facts.js';
+export type { JobSpec, JobCheck, PreparedJob } from './job.js';
 export type { Recorded, UnsignedCall, Network } from './record.js';
 export type { Verification, AnswerEvent, DecisionEvent } from './verify.js';
 export type { Protocol, Adapter, AdapterOpts, EvaluatorCall } from './evaluator/index.js';
@@ -27,3 +32,4 @@ export type { JevError } from './ask.js';
 export type { Rubric, RubricInput, Question, Answer, Facts, Verdict, Composed, Thresholds } from './rubric.js';
 export type { Subject, AnswerRecord } from './records.js';
 export type { Hex } from './hash.js';
+export type { PipelineOpts, Trace, StepId, StepResult, Evidence, QueueRow, Quote } from './pipeline.js';

package/dist/index.js

@@ -1,20 +1,24 @@
 /**
  * @taifoon/jev — Jev as a grader any protocol can call.
  *
+ *   prepareJob()     an agent job as the buyer laid it out → the evidence Jev reads + the code checks
  *   grade()          evidence → deterministic facts → Jev's atomic questions → composed verdict → receipt
  *   facts()          the deterministic checks a protocol supplies (a failed one is final; Jev is not asked)
  *   record()         the unsigned calls that put the receipt's digests on JevAnswerLog / JevDecisionLog
  *   evaluatorCall()  the unsigned call that ends the job on the protocol whose evaluator seat you hold
  *   verify()         recompute every digest and find the chain events that hold them
+ *   pipeline()       one job through the coordination layer's steps: pick → evidence → facts → grade → record → evaluator → premium → verify
  *   RUBRIC_v1        the questions, thresholds and composition (pass your own rubric to grade)
  *   CONTRACTS        where the logs and the evaluator seats are
  *
- * No runtime dependency. No key inside: the free trial, or your own TypeSafe key.
+ * No runtime dependency. No key inside: Jev is called with your own TypeSafe key (console.typesafe.ai).
  */
 export { grade } from './grade.js';
 export { facts } from './facts.js';
+export { prepareJob, runCheck } from './job.js';
 export { record } from './record.js';
 export { evaluatorCall } from './evaluator/index.js';
 export { verify } from './verify.js';
+export { pipeline, STEPS, LAYER, factsFromEvidence, protocolFor, parseJob } from './pipeline.js';
 export { RUBRIC_v1 } from './rubric.js';
 export { CONTRACTS } from './contracts.js';

package/dist/job.d.ts

@@ -0,0 +1,65 @@
+import type { FactsInput } from './facts.js';
+import type { Subject } from './records.js';
+/** A deterministic check on the delivery. `name` labels it in the facts Jev reads (defaults per kind). */
+export type JobCheck = {
+    kind: 'includes';
+    terms: string[];
+    name?: string;
+} | {
+    kind: 'sources';
+    min: number;
+    name?: string;
+} | {
+    kind: 'json';
+    keys: string[];
+    name?: string;
+} | {
+    kind: 'deadline';
+    submittedAt: string;
+    deadline: string;
+    name?: string;
+};
+export type JobSpec = {
+    /** your job id (the subject's ref) */
+    id: string;
+    chainId?: number;
+    /** the contract or protocol address the job lives at, when there is one */
+    at?: string | null;
+    /** what the buyer asked for, in their words */
+    task: string;
+    /** what "done" means, one criterion per line; Jev reads them numbered */
+    criteria: string[];
+    /** what the agent delivered; null when nothing came back (a hard fail) */
+    delivered: string | null;
+    /** material the delivery must be faithful to (an invoice, a dataset, a page); optional */
+    source?: string | null;
+    checks?: JobCheck[];
+    priceUsdc?: number | null;
+    seller?: string | null;
+};
+export type PreparedJob = {
+    subject: Subject;
+    /** what Jev reads (grade() adds the facts section and the instruction) */
+    evidence: {
+        task: string;
+        acceptance_criteria: string;
+        source?: string;
+        delivered: string;
+    };
+    facts: FactsInput;
+    /** the same job as a pipeline() pack: pipeline({ layer: false, evidence: job.pack }) */
+    pack: {
+        subject: string;
+        state: string;
+        delivered: boolean;
+        checks: Record<string, boolean>;
+        priceUsdc: number | null;
+        seller?: string;
+    };
+};
+/** Run one check on the delivery. Pure and synchronous, so the same job always yields the same facts. */
+export declare function runCheck(c: JobCheck, delivered: string): {
+    name: string;
+    ok: boolean;
+};
+export declare function prepareJob(j: JobSpec): PreparedJob;

package/dist/job.js

@@ -0,0 +1,50 @@
+const URL_RE = /https?:\/\/[^\s)\]>"']+/g;
+/** Run one check on the delivery. Pure and synchronous, so the same job always yields the same facts. */
+export function runCheck(c, delivered) {
+    switch (c.kind) {
+        case 'includes': {
+            const low = delivered.toLowerCase();
+            return { name: c.name ?? `mentions ${c.terms.join(', ')}`, ok: c.terms.every((t) => low.includes(t.toLowerCase())) };
+        }
+        case 'sources':
+            return { name: c.name ?? `cites at least ${c.min} source${c.min === 1 ? '' : 's'}`, ok: new Set(delivered.match(URL_RE) ?? []).size >= c.min };
+        case 'json': {
+            let ok = false;
+            try {
+                const v = JSON.parse(delivered);
+                ok = !!v && typeof v === 'object' && !Array.isArray(v) && c.keys.every((k) => k in v);
+            }
+            catch {
+                ok = false;
+            }
+            return { name: c.name ?? `JSON with ${c.keys.join(', ')}`, ok };
+        }
+        case 'deadline':
+            return { name: c.name ?? 'delivered by the deadline', ok: Date.parse(c.submittedAt) <= Date.parse(c.deadline) };
+    }
+}
+export function prepareJob(j) {
+    if (!j.task.trim())
+        throw new Error('prepareJob: a job needs its task');
+    if (!j.criteria.length)
+        throw new Error('prepareJob: a job needs at least one acceptance criterion (what "done" means)');
+    const delivered = j.delivered ?? '';
+    const checks = {};
+    if (j.delivered != null)
+        for (const c of j.checks ?? []) {
+            const r = runCheck(c, delivered);
+            checks[r.name] = r.ok;
+        }
+    const evidence = {
+        task: j.task,
+        acceptance_criteria: j.criteria.map((c, i) => `${i + 1}. ${c}`).join('\n'),
+        ...(j.source ? { source: j.source } : {}),
+        delivered: j.delivered ?? '(nothing was delivered)',
+    };
+    const subject = { chainId: j.chainId ?? 0, at: j.at ?? null, ref: j.id };
+    const facts = { delivered: j.delivered != null && delivered.trim() !== '', checks, priceUsdc: j.priceUsdc ?? null };
+    return {
+        subject, evidence, facts,
+        pack: { subject: j.id, state: JSON.stringify(evidence), delivered: facts.delivered, checks, priceUsdc: j.priceUsdc ?? null, ...(j.seller ? { seller: j.seller } : {}) },
+    };
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,156 @@
+import { type FactsInput } from './facts.js';
+import { type Network, type Recorded } from './record.js';
+import { type Verification } from './verify.js';
+import { type Protocol, type EvaluatorCall } from './evaluator/index.js';
+import type { Receipt } from './receipt.js';
+import type { Answer } from './rubric.js';
+import type { Subject } from './records.js';
+export declare const LAYER = "https://coord.taifoon.dev";
+export type StepId = 'pick' | 'evidence' | 'facts' | 'grade' | 'record' | 'evaluator' | 'premium' | 'verify';
+/** The steps in order, each with the layer route it reads (null: runs locally only). */
+/** `required`: the later steps need its output, so saying no at the gate stops the run instead of skipping it. */
+export declare const STEPS: ReadonlyArray<{
+    id: StepId;
+    title: string;
+    route: string | null;
+    required?: true;
+}>;
+/** One row of /v1/judge/queue, as far as the pipeline reads it. */
+export type QueueRow = {
+    jobId: string;
+    why: string;
+    ending: string;
+    budget: number | null;
+    seller: string;
+    buyer: string;
+    task: string | null;
+    evidence: string;
+    evidence_ready: string;
+};
+/** /v1/judge/evidence/{chain}/{jobId}: `state` is the pack Jev reads; `facts` are [label, value] pairs. */
+export type Evidence = {
+    chainId: number;
+    jobId: string;
+    state: string;
+    facts: Array<[string, string]>;
+    gaps?: string[];
+};
+export type Quote = {
+    guaranteed: boolean;
+    premium: string | null;
+    premium_ratio: number | null;
+    premium_label: string | null;
+    deposit: string | null;
+    record?: {
+        n: number;
+        settled: number;
+        incorrect: number;
+        wilson: [number, number];
+        calibrated: boolean;
+        insurable: boolean;
+    };
+    why?: string[];
+};
+export type LayerRecord = {
+    digest?: string;
+    uri?: string;
+    anchor?: {
+        tx?: string;
+        status?: string;
+    };
+} & Record<string, unknown>;
+export type StepResult<T = unknown> = {
+    id: StepId;
+    ok: boolean;
+    skipped?: string;
+    stopped?: true;
+    ms: number;
+    out?: T;
+    error?: string;
+};
+export type Trace = {
+    job: {
+        chainId: number;
+        jobId: string;
+        seller: string | null;
+    } | null;
+    steps: StepResult[];
+    receipt: Receipt | null;
+    recorded: Recorded | null;
+    layerRecord: LayerRecord | null;
+    evaluator: EvaluatorCall | null;
+    quote: Quote | null;
+    verification: Verification | null;
+};
+export type PipelineOpts = {
+    /** the coordination layer; `false` = never read it (independent mode: `evidence` is required) */
+    layer?: string | false;
+    /** a job to grade, `8453:81100` or { chainId, jobId }; omitted with the layer on: the first ready row of the queue */
+    job?: string | {
+        chainId: number;
+        jobId: string;
+    };
+    /** your own evidence pack; skips pick + evidence */
+    evidence?: {
+        subject: string;
+        chainId?: number;
+        label?: string;
+        state: string;
+        delivered?: boolean;
+        checks?: FactsInput['checks'];
+        priceUsdc?: number | null;
+        seller?: string;
+    };
+    /** your TypeSafe key from console.typesafe.ai (never stored, never recorded) */
+    key?: string | null;
+    /** answers you already have (e.g. from the n8n TypeSafe node): Jev is not asked */
+    answers?: Record<string, Answer> | Answer[];
+    /** the model that produced supplied `answers` (e.g. "jev-1.13.0"); it is part of the decision digest */
+    model?: string | null;
+    /** where record() points the calls; default devnet */
+    /** recording is opt-in: where record() points the calls and what the layer may record. Default none: the receipt and
+     *  its digests only (recomputable offline), no transaction. */
+    network?: Network;
+    /** X-API-Key for POST /v1/judge/answers/record; omitted: nothing is written to the layer */
+    relayerKey?: string | null;
+    /** the job's protocol for the evaluator call; omitted: guessed from the job id */
+    protocol?: Protocol | null;
+    /** a tenant binding (e.g. Moonbeam: { chainId: 8453, at: <hook>, ref: jobId }): overrides the subject grade() records */
+    subject?: (job: {
+        chainId: number;
+        jobId: string;
+    }) => Subject;
+    /** who is grading, recorded in the answer record (e.g. 'moonbeam') */
+    caller?: string;
+    /** read the logs on chain in verify (default: only when record() sent something) */
+    chainVerify?: boolean;
+    /** price for the premium step, in USDC; default: the job's budget */
+    priceUsdc?: number | null;
+    /** a gate before each step: return false to skip it. The interactive CLI asks here. */
+    before?: (step: (typeof STEPS)[number], trace: Trace) => boolean | Promise<boolean>;
+    /** called after each step with its result */
+    after?: (result: StepResult, trace: Trace) => void | Promise<void>;
+    fetch?: typeof fetch;
+};
+/** A job reference: `8453:81100`, `8453:bitagent:8453:7287`, or a bare id (chain 8453). */
+export declare function parseJob(j: string | {
+    chainId: number;
+    jobId: string;
+}): {
+    chainId: number;
+    jobId: string;
+};
+/** The layer's queue rows a grader can actually read: evidence must resolve (decimal id or label:chain:id). */
+export declare const readable: (r: QueueRow) => boolean;
+/**
+ * The deterministic facts an ERC-8183 evidence pack supports on its own:
+ * delivered = the pack names a delivery; submitted_before_deadline when both times are on chain; priceUsdc from "price".
+ * A protocol that can re-derive the delivery (a proof, a hash, a file) adds its own checks on top.
+ */
+export declare function factsFromEvidence(ev: Evidence, extra?: FactsInput['checks']): FactsInput;
+/** The evaluator seat for a job id, when the id says which protocol it is on. */
+export declare function protocolFor(jobId: string): {
+    protocol: Protocol;
+    id: string;
+} | null;
+export declare function pipeline(o?: PipelineOpts): Promise<Trace>;