@ixo/decision-oracle 0.0.0-stage → 0.2.0

package/dist/routes/v1/shared.d.ts

@@ -0,0 +1,586 @@
+/**
+ * What the v1 route files share: the gates every collection-scoped read/write runs, and the
+ * row → response projections (dates as ISO strings, and nothing that shouldn't leave).
+ */
+import type { AppContext } from "../../context.js";
+import { type ClaimIngest, type ClaimReview, type DecisionRow, type WatchedCollection } from "../../db/schema.js";
+/**
+ * Who may READ (and scan) a watched collection — the same surface that may register it, as the
+ * chain says it is NOW (ownership review F2): the current chain owner (who pays the fees), or any
+ * holder of an active on-chain `EvaluateClaimAuthorization` for it (the portal's "Grant Role" flow —
+ * the enroller included, but only while it is still hired). Never the row's memory alone: an
+ * ex-owner or a revoked enroller reads nothing. `reviewers` also lets in a live reviewer of the
+ * collection (company authority D2) — on the claim and review reads they answer from, not on scan.
+ * `agentOf` lets in the named claim's own SUBMITTER (its on-chain agent) — on that one claim's
+ * record only, never the list, reviews, pause/resume or scan; `asAgent` says that is the only
+ * door that opened, so the route can keep others' answers back. It is tried last: the readers above
+ * never pay its Blocksync read, and an outage there is a 503, never a grant.
+ * The chain reads are KV-cached: a stale answer costs a reader five minutes, not a registration.
+ * 404 (not 403) when we don't watch it at all, on purpose: the portal needs to tell "not hired"
+ * apart from "no rights". Returns the gate's projection (callers need cursor/status).
+ */
+export declare function assertCanRead(c: AppContext, collectionId: string, opts?: {
+    reviewers?: boolean;
+    agentOf?: string;
+}): Promise<WatchedGate & {
+    asAgent: boolean;
+}>;
+/**
+ * Who may PAUSE or RESUME a watched collection: the chain owner, an `ORACLE_ADMIN_DIDS` invoker, or the
+ * current enroller WHILE it still holds a live evaluate grant (a revoked enroller is no longer
+ * hired, whatever the row remembers). A plain grant holder may read it but not stall it or lift a
+ * stop — a competing oracle hired on the same collection holds a grant by definition, so either
+ * direction would hand it the collection. 404 unwatched, 403 otherwise. The owner is the row's
+ * `ownerDid` (the chain owner, resolved at register; an entity transfer needs a re-register), so
+ * this costs no chain read beyond the read gate's KV-cached grant read.
+ */
+export declare function assertCanManage(c: AppContext, collectionId: string): Promise<WatchedGate>;
+/**
+ * Who may change a watched collection's SETTINGS (company authority D7) or erase its claims' data
+ * (F14): its CURRENT chain owner only — no enroller, grant holder or operator, since these are the
+ * owner's say over money and data on their collection. Read live off the chain (the collection's entity → its owner), never
+ * the row's `ownerDid`, which an entity transfer leaves stale until a re-register. 404 unwatched,
+ * 403 otherwise; chain trouble throws (a 503), never a silent "not the owner". Answers the owner's
+ * address too: a setting records who set it, so the act lane can tell when the owner has changed.
+ */
+export declare function assertChainOwner(c: AppContext, collectionId: string, 
+/** What the refusal says the owner alone may do. */
+what?: string): Promise<WatchedGate & {
+    owner: string;
+}>;
+/**
+ * What the gates read off the row — never the whole row: it carries the owner's delegation CAR (up
+ * to 64 KB), which no identity or status check needs.
+ */
+declare const gateColumns: {
+    collectionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "collectionId";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: true;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    ownerDid: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "ownerDid";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    enrolledByDid: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "enrolledByDid";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "status";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: "active" | "paused";
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: ["active", "paused"];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: number | undefined;
+    }>;
+    cursor: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "cursor";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+};
+export type WatchedGate = Pick<WatchedCollection, keyof typeof gateColumns>;
+export declare function watchedOr404(c: AppContext, collectionId: string): Promise<WatchedGate>;
+export declare const collectionColumns: {
+    collectionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "collectionId";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: true;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    ownerDid: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "ownerDid";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    enrolledByDid: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "enrolledByDid";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    evaluationDenom: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "evaluationDenom";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    evaluationAmount: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "evaluationAmount";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    protocolDid: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "protocolDid";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    rubricId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "rubricId";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    delegationExpiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "delegationExpiresAt";
+        tableName: "watched_collections";
+        dataType: "date";
+        columnType: "SQLiteTimestamp";
+        data: Date;
+        driverParam: number;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    contactEmail: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "contactEmail";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "status";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: "active" | "paused";
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: ["active", "paused"];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: number | undefined;
+    }>;
+    pausedReason: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "pausedReason";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: "admin-unfunded" | "engine-credits" | "engine-no-grant" | "oracle-plan" | "payer-credits" | "payer-delegation" | "rubric-unusable";
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: ["engine-credits", "engine-no-grant", "rubric-unusable", "admin-unfunded", "payer-credits", "payer-delegation", "oracle-plan"];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: number | undefined;
+    }>;
+    billingSourceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "billingSourceId";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    cursor: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "cursor";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    lastScannedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "lastScannedAt";
+        tableName: "watched_collections";
+        dataType: "date";
+        columnType: "SQLiteTimestamp";
+        data: Date;
+        driverParam: number;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    operatorAmounts: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "operatorAmounts";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: "allowed" | "off";
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: ["off", "allowed"];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: number | undefined;
+    }>;
+    operatorAmountsBy: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "operatorAmountsBy";
+        tableName: "watched_collections";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {
+        length: undefined;
+    }>;
+    createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "createdAt";
+        tableName: "watched_collections";
+        dataType: "date";
+        columnType: "SQLiteTimestamp";
+        data: Date;
+        driverParam: number;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: true;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "updatedAt";
+        tableName: "watched_collections";
+        dataType: "date";
+        columnType: "SQLiteTimestamp";
+        data: Date;
+        driverParam: number;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: true;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    hasDelegation: import("drizzle-orm").SQL<boolean>;
+};
+export type CollectionView = Omit<WatchedCollection, "delegationCar"> & {
+    hasDelegation: boolean;
+};
+/** A full row (the register route's) as a `CollectionView`. */
+export declare function viewOf({ delegationCar: car, ...rest }: WatchedCollection): CollectionView;
+export declare function collectionBody(row: CollectionView): {
+    hasDelegation: boolean;
+    delegationExpiresAt: string | null;
+    lastScannedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    billingSourceId: string | null;
+    collectionId: string;
+    contactEmail: string | null;
+    cursor: string | null;
+    enrolledByDid: string;
+    evaluationAmount: string | null;
+    evaluationDenom: string | null;
+    operatorAmounts: "allowed" | "off";
+    operatorAmountsBy: string | null;
+    ownerDid: string;
+    pausedReason: "admin-unfunded" | "engine-credits" | "engine-no-grant" | "oracle-plan" | "payer-credits" | "payer-delegation" | "rubric-unusable" | null;
+    protocolDid: string | null;
+    rubricId: string | null;
+    status: "active" | "paused";
+};
+export declare function ingestBody(row: ClaimIngest): {
+    status: "failed" | "processed" | "processing" | "queued" | "skipped";
+    instanceId: string | null;
+    error: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+/** The engine's answer verbatim — codes, scores and identifiers; the row never held answer values. */
+export declare function decisionBody(row: DecisionRow): {
+    rubricId: string | null;
+    factsDigest: string | null;
+    verdict: string | null;
+    status: string;
+    resultDigest: string | null;
+    receiptCid: string | null;
+    receiptJws: string | null;
+    decision: {
+        [x: string]: unknown;
+        status: "decided" | "pending_review" | "unusable";
+        verdict: "approve" | "partial" | "reject" | "review";
+        class: "insufficient_evidence" | "invalid_evidence" | "out_of_authority" | "partial" | "refuted" | "requires_human_review" | "supported";
+        evaluationStatus: 1 | 2 | 5;
+        action: "auto_approve" | "auto_reject" | "needs_human_review";
+        totalBps: number | null;
+        gates: {
+            [x: string]: unknown;
+            code: string;
+            outcome: "failed" | "not_reached" | "passed" | "skipped" | "unevaluated";
+        }[];
+        criteria: {
+            [x: string]: unknown;
+            code: string;
+            scoreBps: number | null;
+            pending: boolean;
+            capped: boolean;
+        }[];
+        pendingTasks: string[];
+        reasons: {
+            [x: string]: unknown;
+            code: string;
+            reason: string;
+            class: "insufficient_evidence" | "invalid_evidence" | "out_of_authority" | "partial" | "refuted" | "requires_human_review" | "supported";
+        }[];
+    } | null;
+    explanation: string | null;
+    chainStatus: "blocked" | "held" | "owner_submitted" | "pending" | "skipped" | "submitted";
+    txHash: string | null;
+    chainError: string | null;
+    /** Which facts errored and why (engine `erroredFacts`) — null when none did. */
+    erroredFacts: {
+        name: string;
+        detail: string;
+    }[] | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function reviewBody(row: ClaimReview): {
+    answers: Record<string, string | boolean>;
+    reviewerDid: string;
+    /** Whether `reviewerDid` is backed by the reviewer's own signature (design §B.3). The JWS
+     *  itself never leaves: it carries the answer VALUES signed, and a read route has no business
+     *  handing that to anyone who can read the collection. */
+    signed: boolean;
+    answeredAt: string;
+    foldedAt: string | null;
+    /** Why the fold did not land (e.g. the engine's STALE_REVIEW) — null until it fails, cleared by a re-POST. */
+    foldError: string | null;
+};
+export {};
+//# sourceMappingURL=shared.d.ts.map

package/dist/routes/v1/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/shared.ts"],"names":[],"mappings":"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"}