@jinn-network/client 0.1.7 → 0.1.8-canary.09a3b2f6

package/dist/types/payloads/prediction-apy-v0.d.ts

@@ -151,6 +151,7 @@ export declare const PredictionApyV0VerdictPayloadSchema: z.ZodEffects<z.ZodObje
         predictedBps: string;
         submissionManifestCid?: string | undefined;
     };
+    score: string;
     solutionEnvelope: {
         cid: string;
         sha256: string;
@@ -171,7 +172,6 @@ export declare const PredictionApyV0VerdictPayloadSchema: z.ZodEffects<z.ZodObje
         }[];
         overall: "valid" | "invalid";
     };
-    score: string;
     scoreBasis: "absolute-error-linear.v1";
     scoreVersion: string;
     oracleReading: {
@@ -193,6 +193,7 @@ export declare const PredictionApyV0VerdictPayloadSchema: z.ZodEffects<z.ZodObje
         predictedBps: string;
         submissionManifestCid?: string | undefined;
     };
+    score: string;
     solutionEnvelope: {
         cid: string;
         sha256: string;
@@ -213,7 +214,6 @@ export declare const PredictionApyV0VerdictPayloadSchema: z.ZodEffects<z.ZodObje
         }[];
         overall: "valid" | "invalid";
     };
-    score: string;
     scoreBasis: "absolute-error-linear.v1";
     scoreVersion: string;
     oracleReading: {
@@ -235,6 +235,7 @@ export declare const PredictionApyV0VerdictPayloadSchema: z.ZodEffects<z.ZodObje
         predictedBps: string;
         submissionManifestCid?: string | undefined;
     };
+    score: string;
     solutionEnvelope: {
         cid: string;
         sha256: string;
@@ -255,7 +256,6 @@ export declare const PredictionApyV0VerdictPayloadSchema: z.ZodEffects<z.ZodObje
         }[];
         overall: "valid" | "invalid";
     };
-    score: string;
     scoreBasis: "absolute-error-linear.v1";
     scoreVersion: string;
     oracleReading: {

package/dist/types/payloads/prediction-v0.d.ts

@@ -24,14 +24,14 @@ export declare const PredictionV0RestorationPayloadSchema: z.ZodObject<{
         updatedAt: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         feed: string;
+        updatedAt: number;
         roundId: string;
         answer: string;
-        updatedAt: number;
     }, {
         feed: string;
+        updatedAt: number;
         roundId: string;
         answer: string;
-        updatedAt: number;
     }>>;
     rationale: z.ZodOptional<z.ZodArray<z.ZodObject<{
         ts: z.ZodNumber;
@@ -55,9 +55,9 @@ export declare const PredictionV0RestorationPayloadSchema: z.ZodObject<{
     }[] | undefined;
     oracleSnapshot?: {
         feed: string;
+        updatedAt: number;
         roundId: string;
         answer: string;
-        updatedAt: number;
     } | undefined;
 }, {
     prediction: {
@@ -71,9 +71,9 @@ export declare const PredictionV0RestorationPayloadSchema: z.ZodObject<{
     }[] | undefined;
     oracleSnapshot?: {
         feed: string;
+        updatedAt: number;
         roundId: string;
         answer: string;
-        updatedAt: number;
     } | undefined;
 }>;
 export type PredictionV0RestorationPayload = z.infer<typeof PredictionV0RestorationPayloadSchema>;
@@ -139,15 +139,15 @@ export declare const PredictionV0VerdictPayloadSchema: z.ZodEffects<z.ZodObject<
         nextRoundUpdatedAt: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         feed: string;
+        updatedAt: number;
         roundId: string;
         answer: string;
-        updatedAt: number;
         nextRoundUpdatedAt?: number | undefined;
     }, {
         feed: string;
+        updatedAt: number;
         roundId: string;
         answer: string;
-        updatedAt: number;
         nextRoundUpdatedAt?: number | undefined;
     }>;
     claimed: z.ZodObject<{
@@ -188,6 +188,7 @@ export declare const PredictionV0VerdictPayloadSchema: z.ZodEffects<z.ZodObject<
         modelId: string;
         submissionManifestCid?: string | undefined;
     };
+    score: string;
     solutionEnvelope: {
         cid: string;
         sha256: string;
@@ -208,14 +209,13 @@ export declare const PredictionV0VerdictPayloadSchema: z.ZodEffects<z.ZodObject<
         }[];
         overall: "valid" | "invalid";
     };
-    score: string;
     scoreBasis: "brier.v1";
     scoreVersion: string;
     oracleReading: {
         feed: string;
+        updatedAt: number;
         roundId: string;
         answer: string;
-        updatedAt: number;
         nextRoundUpdatedAt?: number | undefined;
     };
     groundTruth: "YES" | "NO";
@@ -227,6 +227,7 @@ export declare const PredictionV0VerdictPayloadSchema: z.ZodEffects<z.ZodObject<
         modelId: string;
         submissionManifestCid?: string | undefined;
     };
+    score: string;
     solutionEnvelope: {
         cid: string;
         sha256: string;
@@ -247,14 +248,13 @@ export declare const PredictionV0VerdictPayloadSchema: z.ZodEffects<z.ZodObject<
         }[];
         overall: "valid" | "invalid";
     };
-    score: string;
     scoreBasis: "brier.v1";
     scoreVersion: string;
     oracleReading: {
         feed: string;
+        updatedAt: number;
         roundId: string;
         answer: string;
-        updatedAt: number;
         nextRoundUpdatedAt?: number | undefined;
     };
     groundTruth: "YES" | "NO";
@@ -266,6 +266,7 @@ export declare const PredictionV0VerdictPayloadSchema: z.ZodEffects<z.ZodObject<
         modelId: string;
         submissionManifestCid?: string | undefined;
     };
+    score: string;
     solutionEnvelope: {
         cid: string;
         sha256: string;
@@ -286,14 +287,13 @@ export declare const PredictionV0VerdictPayloadSchema: z.ZodEffects<z.ZodObject<
         }[];
         overall: "valid" | "invalid";
     };
-    score: string;
     scoreBasis: "brier.v1";
     scoreVersion: string;
     oracleReading: {
         feed: string;
+        updatedAt: number;
         roundId: string;
         answer: string;
-        updatedAt: number;
         nextRoundUpdatedAt?: number | undefined;
     };
     groundTruth: "YES" | "NO";

package/dist/vendor/@jinn-network/sdk/dist/payloads/swe-rebench-v2.d.ts

@@ -84,7 +84,7 @@ export declare const SweRebenchV2SolutionPayloadSchema: z.ZodObject<{
     } | undefined;
 }>;
 export type SweRebenchV2SolutionPayload = z.infer<typeof SweRebenchV2SolutionPayloadSchema>;
-export declare const SweRebenchV2VerdictPayloadSchema: z.ZodObject<{
+export declare const SweRebenchV2VerdictV1PayloadSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"swe-rebench-v2-verdict.v1">;
     /** Pass@1 score: 1 if the test suite passed, 0 otherwise. */
     score: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
@@ -107,4 +107,111 @@ export declare const SweRebenchV2VerdictPayloadSchema: z.ZodObject<{
     passed_match: boolean;
     evaluator_cost_usd: number;
 }>;
+/**
+ * v2 — additive graded signal (Lever A, #1019). Superset of v1: keeps the
+ * binary `score`/`passed_match` (the objective) and adds the per-test counts
+ * the grader already computes. `gradedScore = passedCount / totalCount` is
+ * derived downstream, never stored, to keep one source of truth.
+ */
+export declare const SweRebenchV2VerdictV2PayloadSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"swe-rebench-v2-verdict.v2">;
+    score: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    passed_match: z.ZodBoolean;
+    evaluator_cost_usd: z.ZodNumber;
+    /** Count of individual tests that passed in this run. */
+    passedCount: z.ZodNumber;
+    /** Total gradeable tests in this run (FAIL_TO_PASS ∪ PASS_TO_PASS as the runner reported). */
+    totalCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}>, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}>;
+/** Accept either schema version on the read path. */
+export declare const SweRebenchV2VerdictPayloadSchema: z.ZodUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"swe-rebench-v2-verdict.v1">;
+    /** Pass@1 score: 1 if the test suite passed, 0 otherwise. */
+    score: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    /**
+     * Whether the actual passed/failed test set matched the expected
+     * `FAIL_TO_PASS ∪ PASS_TO_PASS` exactly. False if extra tests passed
+     * or expected tests failed unexpectedly.
+     */
+    passed_match: z.ZodBoolean;
+    /** Cost of running the evaluator on this Solution (USDC-equivalent). */
+    evaluator_cost_usd: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "swe-rebench-v2-verdict.v1";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+}, {
+    schemaVersion: "swe-rebench-v2-verdict.v1";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+}>, z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"swe-rebench-v2-verdict.v2">;
+    score: z.ZodUnion<[z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+    passed_match: z.ZodBoolean;
+    evaluator_cost_usd: z.ZodNumber;
+    /** Count of individual tests that passed in this run. */
+    passedCount: z.ZodNumber;
+    /** Total gradeable tests in this run (FAIL_TO_PASS ∪ PASS_TO_PASS as the runner reported). */
+    totalCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}>, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}, {
+    schemaVersion: "swe-rebench-v2-verdict.v2";
+    score: 0 | 1;
+    passed_match: boolean;
+    evaluator_cost_usd: number;
+    passedCount: number;
+    totalCount: number;
+}>]>;
+export type SweRebenchV2VerdictV1Payload = z.infer<typeof SweRebenchV2VerdictV1PayloadSchema>;
+export type SweRebenchV2VerdictV2Payload = z.infer<typeof SweRebenchV2VerdictV2PayloadSchema>;
 export type SweRebenchV2VerdictPayload = z.infer<typeof SweRebenchV2VerdictPayloadSchema>;

package/dist/vendor/@jinn-network/sdk/dist/payloads/swe-rebench-v2.js

@@ -43,7 +43,7 @@ export const SweRebenchV2SolutionPayloadSchema = z.object({
     })
         .optional(),
 });
-export const SweRebenchV2VerdictPayloadSchema = z.object({
+export const SweRebenchV2VerdictV1PayloadSchema = z.object({
     schemaVersion: z.literal('swe-rebench-v2-verdict.v1'),
     /** Pass@1 score: 1 if the test suite passed, 0 otherwise. */
     score: z.union([z.literal(0), z.literal(1)]),
@@ -56,3 +56,27 @@ export const SweRebenchV2VerdictPayloadSchema = z.object({
     /** Cost of running the evaluator on this Solution (USDC-equivalent). */
     evaluator_cost_usd: z.number().nonnegative(),
 });
+/**
+ * v2 — additive graded signal (Lever A, #1019). Superset of v1: keeps the
+ * binary `score`/`passed_match` (the objective) and adds the per-test counts
+ * the grader already computes. `gradedScore = passedCount / totalCount` is
+ * derived downstream, never stored, to keep one source of truth.
+ */
+export const SweRebenchV2VerdictV2PayloadSchema = z.object({
+    schemaVersion: z.literal('swe-rebench-v2-verdict.v2'),
+    score: z.union([z.literal(0), z.literal(1)]),
+    passed_match: z.boolean(),
+    evaluator_cost_usd: z.number().nonnegative(),
+    // camelCase matches schemaVersion/totalUsd elsewhere in this file and the #1019 design.
+    /** Count of individual tests that passed in this run. */
+    passedCount: z.number().int().nonnegative(),
+    /** Total gradeable tests in this run (FAIL_TO_PASS ∪ PASS_TO_PASS as the runner reported). */
+    totalCount: z.number().int().nonnegative(),
+}).refine((p) => p.passedCount <= p.totalCount, {
+    message: 'passedCount must not exceed totalCount',
+});
+/** Accept either schema version on the read path. */
+export const SweRebenchV2VerdictPayloadSchema = z.union([
+    SweRebenchV2VerdictV1PayloadSchema,
+    SweRebenchV2VerdictV2PayloadSchema,
+]);

package/dist/vendor/@jinn-network/sdk/dist/solvernets/swe-rebench-v2-held-out-slate.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Held-out task slate for the swe-rebench-v2 RL eval harness (issue #817/#820).
+ *
+ * A slate is a versioned, content-addressed set of swe-rebench-v2
+ * `instance_id`s RESERVED from the training pool. #817 ships the canonical
+ * train-stream exclusion in `client/`; the indexer (this package's consumer)
+ * needs the same membership to slate-scope `frozenResolvedRate` (#820 AC#1),
+ * but the indexer cannot import from `client/` (see
+ * `packages/indexer/src/handlers.ts` header). So the membership is embedded
+ * here, in the SDK both the indexer and clients may depend on.
+ *
+ * The artifact is embedded (not read from disk) so the SDK stays a pure,
+ * bundler-friendly module with no `node:fs` runtime dependency. It carries a
+ * self-declared content hash: the loader recomputes a sha256 over the
+ * canonicalised, instance-id-sorted artifact and fails loud on mismatch. This
+ * preserves #817's fail-loud drift guard — a hand-edit that adds or removes an
+ * instance without re-deriving the hash throws. It is NOT a tamper-proof
+ * anchor (the declared hash lives beside the data it verifies); a deliberate
+ * edit that also re-derives the hash passes.
+ *
+ * The embedded `instanceIds` + `hash` are kept byte-identical to the client
+ * artifact (`client/src/solver-types/slates/held-out-slate.swe-rebench-v2.v1.json`)
+ * by a cross-source drift test. Scores are only comparable WITHIN a version; a
+ * slate change is a distinct version (v2, ...), never an in-place edit.
+ *
+ * Hashing mirrors `_swe-rebench-v2-held-out-slate.ts` in `client/`:
+ * `sha256:` + sha256(RFC 8785 canonical JSON of the normalized artifact). The
+ * artifact shape is flat (string scalars + a string array), so a minimal
+ * inlined JCS canonicalizer reproduces the client's `canonicalize`-based hash
+ * exactly — verified by the drift test.
+ */
+export declare const HELD_OUT_SLATE_SCHEMA_VERSION: "held-out-slate.v1";
+export interface HeldOutSlateArtifact {
+    schemaVersion: typeof HELD_OUT_SLATE_SCHEMA_VERSION;
+    solverType: string;
+    version: string;
+    generatedAt: string;
+    instanceIds: string[];
+    /** Declared content hash (sha256 over the canonical, sorted artifact). */
+    hash: `sha256:${string}`;
+}
+export interface LoadedHeldOutSlate {
+    version: string;
+    hash: `sha256:${string}`;
+    instanceIds: Set<string>;
+}
+/**
+ * Embedded v1 slate. Byte-identical (sans the `comment` doc field, which is not
+ * part of the hashed artifact) to
+ * `client/src/solver-types/slates/held-out-slate.swe-rebench-v2.v1.json`.
+ * Guarded against drift by `test/solvernets/swe-rebench-v2-held-out-slate-cross-source.test.ts`.
+ */
+export declare const HELD_OUT_SLATE_V1: HeldOutSlateArtifact;
+export declare function hashHeldOutSlateArtifact(artifact: HeldOutSlateArtifact): `sha256:${string}`;
+/**
+ * Load the held-out slate membership for the swe-rebench-v2 solverType at
+ * `version`. Recomputes the content hash and fails loud on mismatch against the
+ * artifact's declared `hash` (catching accidental edit-without-rehash drift —
+ * not deliberate tampering; see the module header). Throws for an unknown
+ * version (scores are only comparable within a known version).
+ *
+ * `override` is for tests only — it lets the fail-loud guard be exercised
+ * against a tampered copy without mutating the canonical embedded artifact.
+ */
+export declare function loadHeldOutSlate(version: string, override?: HeldOutSlateArtifact): LoadedHeldOutSlate;

package/dist/vendor/@jinn-network/sdk/dist/solvernets/swe-rebench-v2-held-out-slate.js

@@ -0,0 +1,123 @@
+/**
+ * Held-out task slate for the swe-rebench-v2 RL eval harness (issue #817/#820).
+ *
+ * A slate is a versioned, content-addressed set of swe-rebench-v2
+ * `instance_id`s RESERVED from the training pool. #817 ships the canonical
+ * train-stream exclusion in `client/`; the indexer (this package's consumer)
+ * needs the same membership to slate-scope `frozenResolvedRate` (#820 AC#1),
+ * but the indexer cannot import from `client/` (see
+ * `packages/indexer/src/handlers.ts` header). So the membership is embedded
+ * here, in the SDK both the indexer and clients may depend on.
+ *
+ * The artifact is embedded (not read from disk) so the SDK stays a pure,
+ * bundler-friendly module with no `node:fs` runtime dependency. It carries a
+ * self-declared content hash: the loader recomputes a sha256 over the
+ * canonicalised, instance-id-sorted artifact and fails loud on mismatch. This
+ * preserves #817's fail-loud drift guard — a hand-edit that adds or removes an
+ * instance without re-deriving the hash throws. It is NOT a tamper-proof
+ * anchor (the declared hash lives beside the data it verifies); a deliberate
+ * edit that also re-derives the hash passes.
+ *
+ * The embedded `instanceIds` + `hash` are kept byte-identical to the client
+ * artifact (`client/src/solver-types/slates/held-out-slate.swe-rebench-v2.v1.json`)
+ * by a cross-source drift test. Scores are only comparable WITHIN a version; a
+ * slate change is a distinct version (v2, ...), never an in-place edit.
+ *
+ * Hashing mirrors `_swe-rebench-v2-held-out-slate.ts` in `client/`:
+ * `sha256:` + sha256(RFC 8785 canonical JSON of the normalized artifact). The
+ * artifact shape is flat (string scalars + a string array), so a minimal
+ * inlined JCS canonicalizer reproduces the client's `canonicalize`-based hash
+ * exactly — verified by the drift test.
+ */
+/// <reference types="node" />
+import { createHash } from 'node:crypto';
+export const HELD_OUT_SLATE_SCHEMA_VERSION = 'held-out-slate.v1';
+/**
+ * Embedded v1 slate. Byte-identical (sans the `comment` doc field, which is not
+ * part of the hashed artifact) to
+ * `client/src/solver-types/slates/held-out-slate.swe-rebench-v2.v1.json`.
+ * Guarded against drift by `test/solvernets/swe-rebench-v2-held-out-slate-cross-source.test.ts`.
+ */
+export const HELD_OUT_SLATE_V1 = {
+    schemaVersion: 'held-out-slate.v1',
+    solverType: 'swe-rebench-v2.v1',
+    version: 'v1',
+    generatedAt: '2026-05-29T00:00:00.000Z',
+    hash: 'sha256:2b029de15e271d5d2de35fe6477af98aef9fdc46f357e59139179edab1a42b15',
+    instanceIds: [
+        'ASPP__pelita-863',
+        'ASPP__pelita-875',
+        'AbsaOSS__generate-release-notes-207',
+        'All-Hands-AI__OpenHands-11914',
+        'BQSKit__bqskit-337',
+        'BerriAI__litellm-14715',
+        'BerriAI__litellm-15753',
+        'BrianPugh__cyclopts-609',
+        'carsdotcom__skelebot-280',
+        'pandas-dev__pandas-60736',
+    ],
+};
+const SLATES_BY_VERSION = {
+    v1: HELD_OUT_SLATE_V1,
+};
+/**
+ * Minimal RFC 8785 (JCS) serialization for the flat slate artifact: object keys
+ * sorted by UTF-16 code-unit order, string values JSON-escaped, arrays in
+ * order. Reproduces the client loader's `canonicalize`-based output for this
+ * shape exactly (the cross-source drift test locks this against the client
+ * artifact's declared hash).
+ */
+function canonicalJson(value) {
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (value !== null && typeof value === 'object') {
+        const keys = Object.keys(value).sort();
+        return `{${keys
+            .map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+/**
+ * The hashed projection: schema/solver/version/generatedAt + the sorted
+ * instanceIds. Excludes the `hash` field itself (a hash never hashes itself).
+ */
+function normalizeHeldOutSlateArtifact(artifact) {
+    return {
+        schemaVersion: HELD_OUT_SLATE_SCHEMA_VERSION,
+        solverType: artifact.solverType,
+        version: artifact.version,
+        generatedAt: artifact.generatedAt,
+        instanceIds: [...artifact.instanceIds].sort((a, b) => a.localeCompare(b)),
+    };
+}
+export function hashHeldOutSlateArtifact(artifact) {
+    const canonical = canonicalJson(normalizeHeldOutSlateArtifact(artifact));
+    return `sha256:${createHash('sha256').update(canonical).digest('hex')}`;
+}
+/**
+ * Load the held-out slate membership for the swe-rebench-v2 solverType at
+ * `version`. Recomputes the content hash and fails loud on mismatch against the
+ * artifact's declared `hash` (catching accidental edit-without-rehash drift —
+ * not deliberate tampering; see the module header). Throws for an unknown
+ * version (scores are only comparable within a known version).
+ *
+ * `override` is for tests only — it lets the fail-loud guard be exercised
+ * against a tampered copy without mutating the canonical embedded artifact.
+ */
+export function loadHeldOutSlate(version, override) {
+    const artifact = override ?? SLATES_BY_VERSION[version];
+    if (!artifact) {
+        throw new Error(`held-out slate not found for swe-rebench-v2 version=${version}`);
+    }
+    if (artifact.version !== version) {
+        throw new Error(`held-out slate version mismatch: artifact declares ${artifact.version}, requested ${version}`);
+    }
+    const computed = hashHeldOutSlateArtifact(artifact);
+    if (artifact.hash !== computed) {
+        throw new Error(`held-out slate hash mismatch for swe-rebench-v2 ${version}: declared ${artifact.hash}, computed ${computed} (artifact was edited without re-deriving the hash)`);
+    }
+    return { version: artifact.version, hash: computed, instanceIds: new Set(artifact.instanceIds) };
+}

package/dist/vendor/@jinn-network/sdk/dist/solvernets/swe-rebench-v2.d.ts

@@ -1,4 +1,4 @@
 export { SweRebenchV2LanguageSchema, SweRebenchV2TaskSchema, } from '../swe-rebench-v2.js';
 export type { SweRebenchV2Task } from '../swe-rebench-v2.js';
-export { SweRebenchV2SolutionPayloadSchema, SweRebenchV2VerdictPayloadSchema, } from '../payloads/swe-rebench-v2.js';
-export type { SweRebenchV2SolutionPayload, SweRebenchV2VerdictPayload, } from '../payloads/swe-rebench-v2.js';
+export { SweRebenchV2SolutionPayloadSchema, SweRebenchV2VerdictPayloadSchema, SweRebenchV2VerdictV2PayloadSchema, } from '../payloads/swe-rebench-v2.js';
+export type { SweRebenchV2SolutionPayload, SweRebenchV2VerdictPayload, SweRebenchV2VerdictV2Payload, } from '../payloads/swe-rebench-v2.js';

package/dist/vendor/@jinn-network/sdk/dist/solvernets/swe-rebench-v2.js

@@ -1,2 +1,2 @@
 export { SweRebenchV2LanguageSchema, SweRebenchV2TaskSchema, } from '../swe-rebench-v2.js';
-export { SweRebenchV2SolutionPayloadSchema, SweRebenchV2VerdictPayloadSchema, } from '../payloads/swe-rebench-v2.js';
+export { SweRebenchV2SolutionPayloadSchema, SweRebenchV2VerdictPayloadSchema, SweRebenchV2VerdictV2PayloadSchema, } from '../payloads/swe-rebench-v2.js';

package/dist/vendor/@jinn-network/sdk/package.json

@@ -31,6 +31,10 @@
       "import": "./dist/solvernets/swe-rebench-v2.js",
       "types": "./dist/solvernets/swe-rebench-v2.d.ts"
     },
+    "./solvernets/swe-rebench-v2-held-out-slate": {
+      "import": "./dist/solvernets/swe-rebench-v2-held-out-slate.js",
+      "types": "./dist/solvernets/swe-rebench-v2-held-out-slate.d.ts"
+    },
     "./checkpoint": {
       "import": "./dist/checkpoint.js",
       "types": "./dist/checkpoint.d.ts"

package/docker-compose.yml

@@ -33,8 +33,9 @@ services:
     volumes:
       # Persistent daemon state: database, keystore, and earning progress
       - jinn-data:/data
-      # Persistent authentication state: stores Claude's OAuth token
-      - jinn-claude-state:/root/.claude
+      # Persistent authentication state: stores Claude's OAuth token. The image
+      # now runs as the non-root `node` user, so file-auth lives at /home/node/.claude.
+      - jinn-claude-state:/home/node/.claude
     command: ["run"]
 
 volumes: