@jinn-network/client 0.1.3-canary.2d6b2676 → 0.1.3-canary.8e61ba74

package/dist/vendor/@jinn-network/sdk/dist/contracts.js

@@ -0,0 +1,147 @@
+import { PredictionV1TaskSchema } from './prediction-v1.js';
+import { PredictionV1RestorationPayloadSchema, PredictionV1VerdictPayloadSchema, } from './payloads/prediction-v1.js';
+export const PREDICTION_V1_SOLVER_NET_CONTRACT = {
+    name: 'Prediction',
+    solverType: 'prediction.v1',
+    schemas: {
+        task: PredictionV1TaskSchema,
+        solution: PredictionV1RestorationPayloadSchema,
+        verdict: PredictionV1VerdictPayloadSchema,
+    },
+    claimPolicyDefaults: {
+        mode: 'parallel',
+        maxClaims: 25,
+        maxClaimsPerOperator: 1,
+        claimLeaseTtlSeconds: 30 * 60,
+    },
+    credentialRequirements: {
+        creator: [
+            {
+                id: 'polymarket.public.market-data.read',
+                kind: 'public-api',
+                required: true,
+                description: 'Read public Polymarket market metadata and orderbook snapshots for Task creation.',
+            },
+        ],
+        solver: [],
+        evaluator: [
+            {
+                id: 'polymarket.public.resolution.read',
+                kind: 'public-api',
+                required: true,
+                description: 'Read public Polymarket/UMA final market state for resolution mapping.',
+            },
+        ],
+    },
+    evaluationFunction: {
+        id: 'prediction.brier-loss.v1',
+        deterministic: true,
+        inputs: ['prediction.v1 Task', 'prediction.v1 Solution', 'Polymarket/UMA resolution'],
+        output: 'prediction.v1 Verdict',
+        implementation: 'client/src/harnesses/impls/prediction-v1-evaluator',
+    },
+    aggregationFunction: {
+        id: 'prediction.trailing-mean-brier-spread.v1',
+        deterministic: true,
+        inputs: ['SCORED prediction.v1 Verdicts'],
+        output: 'trailing mean brierSpread',
+        windowDays: 84,
+    },
+    referencePlugins: ['bundled:jinn-prediction-plugin'],
+};
+export const SOLVER_NET_CONTRACTS = {
+    'prediction.v1': PREDICTION_V1_SOLVER_NET_CONTRACT,
+};
+export function getSolverNetContract(solverType) {
+    return SOLVER_NET_CONTRACTS[solverType];
+}
+export class PayloadValidationException extends Error {
+    code;
+    issues;
+    constructor(code, message, issues = []) {
+        super(message);
+        this.name = 'PayloadValidationException';
+        this.code = code;
+        this.issues = issues;
+    }
+}
+function issuesFrom(error) {
+    return error.issues.map((issue) => ({
+        path: issue.path.length > 0 ? issue.path.join('.') : '<root>',
+        message: issue.message,
+    }));
+}
+function getSchema(solverType, kind) {
+    return getSolverNetContract(solverType)?.schemas[kind];
+}
+function validateWithSchema(solverType, kind, value) {
+    const schema = getSchema(solverType, kind);
+    if (!schema) {
+        return {
+            ok: false,
+            error: {
+                code: 'unsupported_solver_type',
+                message: `Unsupported SolverType for ${kind} validation: ${solverType}`,
+                issues: [],
+            },
+        };
+    }
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+        const issues = issuesFrom(parsed.error);
+        return {
+            ok: false,
+            error: {
+                code: 'invalid_payload',
+                message: `${solverType} ${kind} failed validation: ${issues.map((issue) => `${issue.path}: ${issue.message}`).join('; ')}`,
+                issues,
+            },
+        };
+    }
+    return { ok: true, value: parsed.data };
+}
+function assertValid(result) {
+    if (result.ok)
+        return result.value;
+    throw new PayloadValidationException(result.error.code, result.error.message, result.error.issues);
+}
+export function validateTask(solverType, task) {
+    return validateWithSchema(solverType, 'task', task);
+}
+export function assertTask(solverType, task) {
+    return assertValid(validateTask(solverType, task));
+}
+export function validateSolutionPayload(solverType, payload) {
+    return validateWithSchema(solverType, 'solution', payload);
+}
+export function assertSolutionPayload(solverType, payload) {
+    return assertValid(validateSolutionPayload(solverType, payload));
+}
+export function validateVerdictPayload(solverType, payload) {
+    return validateWithSchema(solverType, 'verdict', payload);
+}
+export function assertVerdictPayload(solverType, payload) {
+    return assertValid(validateVerdictPayload(solverType, payload));
+}
+export function buildSolutionOutput(args) {
+    const payload = assertSolutionPayload(args.solverType, args.payload);
+    return {
+        venueRef: { name: args.venueName },
+        gating: args.gating ?? {},
+        ...(args.informational ? { informational: args.informational } : {}),
+        solutionPayload: payload,
+        ...(args.artifacts ? { artifacts: args.artifacts } : {}),
+        ...(args.rationale ? { rationale: args.rationale } : {}),
+    };
+}
+export function buildVerdictOutput(args) {
+    const payload = assertVerdictPayload(args.solverType, args.payload);
+    return {
+        venueRef: { name: args.venueName ?? 'jinn-evaluator' },
+        gating: args.gating ?? {},
+        ...(args.informational ? { informational: args.informational } : {}),
+        verdictPayload: payload,
+        ...(args.artifacts ? { artifacts: args.artifacts } : {}),
+        ...(args.rationale ? { rationale: args.rationale } : {}),
+    };
+}

package/dist/vendor/@jinn-network/sdk/dist/harness.d.ts

@@ -0,0 +1,69 @@
+export type { Address, Hex, IntentWindow, Task, OutputArtifact, RationaleEntry, Solution, TrajectoryCollector, TrajectorySpanInput, ReadyStatus, EnableArgDef, IntentEnableMetadata, EnableResult, } from './types.js';
+export { REQUIRES_LIVE_DAEMON_READINESS, SkippableError } from './types.js';
+export type { SignTypedDataArgs, SendAllowedCallArgs, ScopedSigner, ScopedRpc, ScopedSecrets, } from './capabilities.js';
+export type { CapabilityAllowEntry, ManifestRpcAllow, ManifestSecretSpec, TypedDataAllowEntry, JinnManifest, } from './manifest.js';
+import type { Task, Solution, TrajectoryCollector, ReadyStatus, IntentEnableMetadata, EnableResult } from './types.js';
+import type { ScopedSigner, ScopedRpc, ScopedSecrets } from './capabilities.js';
+export interface HarnessContext {
+    task: Task;
+    taskCid?: string;
+    implStateDir: string;
+    workingDir: string;
+    log: (event: {
+        level: 'info' | 'warn' | 'error';
+        msg: string;
+        data?: unknown;
+    }) => void;
+    abort: AbortSignal;
+    msUntilEndTs: () => number;
+    trajectory: TrajectoryCollector;
+    signer?: ScopedSigner;
+    rpc?: ScopedRpc;
+    secrets?: ScopedSecrets;
+}
+/**
+ * Construction-time environment passed to the impl factory.
+ * Per-attempt Task inputs are provided through HarnessContext.
+ */
+export interface ExternalHarnessEnv {
+    readonly implName: string;
+    readonly implVersion: string;
+    readonly network: string;
+    readonly implStateDir: string;
+    readonly secrets: ScopedSecrets;
+    readonly log: HarnessContext['log'];
+    /** True for CLI introspection; impls should report stub readiness. */
+    readonly stub: boolean;
+}
+export interface Harness {
+    name: string;
+    version: string;
+    supports(ctx: {
+        solverType: string;
+        role?: 'restoration' | 'evaluation';
+    }): boolean;
+    canAttempt?(task: Task): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
+    }>;
+    run(ctx: HarnessContext): Promise<Solution>;
+    isReady?(spec?: {
+        solverType: string;
+        role?: 'restoration' | 'evaluation';
+    }): Promise<ReadyStatus>;
+    enableMetadata?(): IntentEnableMetadata;
+    onEnable?(args: Record<string, string | undefined>, spec?: {
+        solverType: string;
+        role?: 'restoration' | 'evaluation';
+    }): Promise<EnableResult>;
+    onDisable?(spec?: {
+        solverType: string;
+        role?: 'restoration' | 'evaluation';
+    }): Promise<void>;
+}
+/**
+ * External-impl factory: default-export shape for external Harness packages.
+ */
+export type ExternalHarnessFactory = (env: ExternalHarnessEnv) => Harness;

package/dist/vendor/@jinn-network/sdk/dist/harness.js

@@ -0,0 +1 @@
+export { REQUIRES_LIVE_DAEMON_READINESS, SkippableError } from './types.js';

package/dist/vendor/@jinn-network/sdk/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { Address, Hex, IntentWindow, Task, OutputArtifact, RationaleEntry, Solution, TrajectoryCollector, TrajectorySpanInput, ReadyStatus, EnableArgDef, IntentEnableMetadata, EnableResult, } from './types.js';
+export { REQUIRES_LIVE_DAEMON_READINESS, SkippableError } from './types.js';

package/dist/vendor/@jinn-network/sdk/dist/index.js

@@ -0,0 +1,5 @@
+// @jinn-network/sdk
+//
+// Minimal generic SDK root. Use role-oriented subpaths for execution,
+// SolverNet, plugin, and first-party SolverNet helpers.
+export { REQUIRES_LIVE_DAEMON_READINESS, SkippableError } from './types.js';

package/dist/vendor/@jinn-network/sdk/dist/manifest.d.ts

@@ -0,0 +1,69 @@
+export interface CapabilityAllowEntry {
+    chainId: number;
+    to: `0x${string}`;
+    selector: `0x${string}`;
+    description?: string;
+}
+/**
+ * EIP-712 typed-data domain allow-list entry.
+ *
+ * The daemon's scoped signer refuses any `signTypedData` call whose
+ * domain does not match one of these entries:
+ * - `chainId` MUST match exactly.
+ * - `verifyingContract` / `name` / `version` match only when set on
+ *   the entry; an unset field on the entry means "any value".
+ * - An empty / omitted `typedDataDomains` array means default-deny:
+ *   every `signTypedData` call throws.
+ */
+export interface TypedDataAllowEntry {
+    chainId: number;
+    name?: string;
+    version?: string;
+    verifyingContract?: `0x${string}`;
+}
+export interface ManifestRpcAllow {
+    chainId: number;
+    methods: ReadonlyArray<'eth_call' | 'eth_getBlockByNumber' | 'eth_getLogs' | 'eth_getTransactionReceipt' | 'eth_chainId' | 'eth_blockNumber' | 'eth_getBalance' | 'eth_getCode'>;
+    rateLimit?: {
+        perSec: number;
+    };
+}
+export interface ManifestSecretSpec {
+    name: string;
+    description: string;
+    required: boolean;
+}
+export interface JinnManifest {
+    schemaVersion: '1.0.0';
+    name: string;
+    version: string;
+    description?: string;
+    /** Each entry follows `<domain>.v<major>(>=<semver>)` from spec/2026-05-schema-versioning.md. */
+    supportedSolverTypes: readonly string[];
+    /** Path to the entrypoint module, relative to the package root. */
+    entry: string;
+    /** Tarball CID + sha256 (set at publish time). */
+    package: {
+        cid: string;
+        hash: `sha256:${string}`;
+    };
+    capabilities: {
+        signer?: {
+            selectors: ReadonlyArray<CapabilityAllowEntry>;
+            typedDataDomains?: ReadonlyArray<TypedDataAllowEntry>;
+        };
+        rpc?: ReadonlyArray<ManifestRpcAllow>;
+        secrets?: ReadonlyArray<ManifestSecretSpec>;
+    };
+    /** Detached signature object — not part of the canonicalised manifest. */
+    signature: {
+        alg: 'ed25519';
+        publicKey: string;
+        sig: string;
+    };
+    author?: {
+        name: string;
+        url?: string;
+    };
+    license?: string;
+}

package/dist/vendor/@jinn-network/sdk/dist/manifest.js

@@ -0,0 +1,3 @@
+// JinnManifest — the signed package manifest each external Harness ships.
+// See `spec/2026-05-executor-trust-boundary.md` §5.
+export {};

package/dist/vendor/@jinn-network/sdk/dist/payloads/prediction-v1.d.ts

@@ -0,0 +1,223 @@
+import { z } from 'zod';
+export declare const PredictionV1RestorationPayloadSchema: z.ZodObject<{
+    probabilityYes: z.ZodString;
+    submittedAt: z.ZodString;
+    format: z.ZodLiteral<"decimal">;
+    modelId: z.ZodString;
+    confidence: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    methodology: z.ZodOptional<z.ZodString>;
+    evidenceCids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    reasoningCid: z.ZodOptional<z.ZodString>;
+    sourceRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        title: string;
+    }, {
+        url: string;
+        title: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    probabilityYes: string;
+    submittedAt: string;
+    format: "decimal";
+    modelId: string;
+    confidence?: "low" | "medium" | "high" | undefined;
+    methodology?: string | undefined;
+    evidenceCids?: string[] | undefined;
+    reasoningCid?: string | undefined;
+    sourceRefs?: {
+        url: string;
+        title: string;
+    }[] | undefined;
+}, {
+    probabilityYes: string;
+    submittedAt: string;
+    format: "decimal";
+    modelId: string;
+    confidence?: "low" | "medium" | "high" | undefined;
+    methodology?: string | undefined;
+    evidenceCids?: string[] | undefined;
+    reasoningCid?: string | undefined;
+    sourceRefs?: {
+        url: string;
+        title: string;
+    }[] | undefined;
+}>;
+export type PredictionV1RestorationPayload = z.infer<typeof PredictionV1RestorationPayloadSchema>;
+export declare const PredictionV1VerdictPayloadSchema: z.ZodObject<{
+    verdict: z.ZodEnum<["SCORED", "REJECTED", "INVALID", "INDETERMINATE"]>;
+    outcome: z.ZodOptional<z.ZodEnum<["YES", "NO", "INVALID"]>>;
+    resolvedAt: z.ZodOptional<z.ZodString>;
+    resolutionSource: z.ZodObject<{
+        venue: z.ZodLiteral<"polymarket">;
+        url: z.ZodString;
+        marketId: z.ZodString;
+        conditionId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        venue: "polymarket";
+        url: string;
+        marketId: string;
+        conditionId: string;
+    }, {
+        venue: "polymarket";
+        url: string;
+        marketId: string;
+        conditionId: string;
+    }>;
+    task: z.ZodObject<{
+        cid: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        cid: string;
+        id: string;
+    }, {
+        cid: string;
+        id: string;
+    }>;
+    solutionEnvelope: z.ZodObject<{
+        cid: z.ZodString;
+        sha256: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        cid: string;
+        sha256: string;
+    }, {
+        cid: string;
+        sha256: string;
+    }>;
+    claimed: z.ZodOptional<z.ZodObject<{
+        probabilityYes: z.ZodString;
+        submittedAt: z.ZodString;
+        modelId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        probabilityYes: string;
+        submittedAt: string;
+        modelId: string;
+    }, {
+        probabilityYes: string;
+        submittedAt: string;
+        modelId: string;
+    }>>;
+    benchmark: z.ZodObject<{
+        probabilityYes: z.ZodString;
+        sampledAt: z.ZodString;
+        method: z.ZodLiteral<"best-bid-ask-midpoint">;
+    }, "strip", z.ZodTypeAny, {
+        sampledAt: string;
+        probabilityYes: string;
+        method: "best-bid-ask-midpoint";
+    }, {
+        sampledAt: string;
+        probabilityYes: string;
+        method: "best-bid-ask-midpoint";
+    }>;
+    scores: z.ZodOptional<z.ZodObject<{
+        scoreBasis: z.ZodLiteral<"brier-loss.v1">;
+        solverBrier: z.ZodString;
+        consensusBrier: z.ZodString;
+        brierSpread: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        scoreBasis: "brier-loss.v1";
+        solverBrier: string;
+        consensusBrier: string;
+        brierSpread: string;
+    }, {
+        scoreBasis: "brier-loss.v1";
+        solverBrier: string;
+        consensusBrier: string;
+        brierSpread: string;
+    }>>;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<["PASS", "FAIL", "SKIP", "INDETERMINATE"]>;
+        detail: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "PASS" | "FAIL" | "SKIP" | "INDETERMINATE";
+        name: string;
+        detail?: string | Record<string, unknown> | undefined;
+    }, {
+        status: "PASS" | "FAIL" | "SKIP" | "INDETERMINATE";
+        name: string;
+        detail?: string | Record<string, unknown> | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    verdict: "INDETERMINATE" | "SCORED" | "REJECTED" | "INVALID";
+    resolutionSource: {
+        venue: "polymarket";
+        url: string;
+        marketId: string;
+        conditionId: string;
+    };
+    task: {
+        cid: string;
+        id: string;
+    };
+    solutionEnvelope: {
+        cid: string;
+        sha256: string;
+    };
+    benchmark: {
+        sampledAt: string;
+        probabilityYes: string;
+        method: "best-bid-ask-midpoint";
+    };
+    checks: {
+        status: "PASS" | "FAIL" | "SKIP" | "INDETERMINATE";
+        name: string;
+        detail?: string | Record<string, unknown> | undefined;
+    }[];
+    outcome?: "YES" | "NO" | "INVALID" | undefined;
+    resolvedAt?: string | undefined;
+    claimed?: {
+        probabilityYes: string;
+        submittedAt: string;
+        modelId: string;
+    } | undefined;
+    scores?: {
+        scoreBasis: "brier-loss.v1";
+        solverBrier: string;
+        consensusBrier: string;
+        brierSpread: string;
+    } | undefined;
+}, {
+    verdict: "INDETERMINATE" | "SCORED" | "REJECTED" | "INVALID";
+    resolutionSource: {
+        venue: "polymarket";
+        url: string;
+        marketId: string;
+        conditionId: string;
+    };
+    task: {
+        cid: string;
+        id: string;
+    };
+    solutionEnvelope: {
+        cid: string;
+        sha256: string;
+    };
+    benchmark: {
+        sampledAt: string;
+        probabilityYes: string;
+        method: "best-bid-ask-midpoint";
+    };
+    checks: {
+        status: "PASS" | "FAIL" | "SKIP" | "INDETERMINATE";
+        name: string;
+        detail?: string | Record<string, unknown> | undefined;
+    }[];
+    outcome?: "YES" | "NO" | "INVALID" | undefined;
+    resolvedAt?: string | undefined;
+    claimed?: {
+        probabilityYes: string;
+        submittedAt: string;
+        modelId: string;
+    } | undefined;
+    scores?: {
+        scoreBasis: "brier-loss.v1";
+        solverBrier: string;
+        consensusBrier: string;
+        brierSpread: string;
+    } | undefined;
+}>;
+export type PredictionV1VerdictPayload = z.infer<typeof PredictionV1VerdictPayloadSchema>;

package/dist/vendor/@jinn-network/sdk/dist/payloads/prediction-v1.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { DecimalProbabilitySchema, IsoDateTimeSchema } from '../prediction-v1.js';
+const Sha256Schema = z.string().regex(/^[0-9a-f]{64}$/);
+const CheckSchema = z.object({
+    name: z.string().min(1),
+    status: z.enum(['PASS', 'FAIL', 'SKIP', 'INDETERMINATE']),
+    detail: z.union([z.string(), z.record(z.unknown())]).optional(),
+});
+export const PredictionV1RestorationPayloadSchema = z.object({
+    probabilityYes: DecimalProbabilitySchema,
+    submittedAt: IsoDateTimeSchema,
+    format: z.literal('decimal'),
+    modelId: z.string().min(1),
+    confidence: z.enum(['low', 'medium', 'high']).optional(),
+    methodology: z.string().optional(),
+    evidenceCids: z.array(z.string().min(1)).optional(),
+    reasoningCid: z.string().min(1).optional(),
+    sourceRefs: z
+        .array(z.object({
+        title: z.string().min(1),
+        url: z.string().url(),
+    }))
+        .optional(),
+});
+export const PredictionV1VerdictPayloadSchema = z.object({
+    verdict: z.enum(['SCORED', 'REJECTED', 'INVALID', 'INDETERMINATE']),
+    outcome: z.enum(['YES', 'NO', 'INVALID']).optional(),
+    resolvedAt: IsoDateTimeSchema.optional(),
+    resolutionSource: z.object({
+        venue: z.literal('polymarket'),
+        url: z.string().url(),
+        marketId: z.string().min(1),
+        conditionId: z.string().min(1),
+    }),
+    task: z.object({
+        cid: z.string(),
+        id: z.string().min(1),
+    }),
+    solutionEnvelope: z.object({
+        cid: z.string(),
+        sha256: Sha256Schema,
+    }),
+    claimed: z
+        .object({
+        probabilityYes: DecimalProbabilitySchema,
+        submittedAt: IsoDateTimeSchema,
+        modelId: z.string().min(1),
+    })
+        .optional(),
+    benchmark: z.object({
+        probabilityYes: DecimalProbabilitySchema,
+        sampledAt: IsoDateTimeSchema,
+        method: z.literal('best-bid-ask-midpoint'),
+    }),
+    scores: z
+        .object({
+        scoreBasis: z.literal('brier-loss.v1'),
+        solverBrier: z.string(),
+        consensusBrier: z.string(),
+        brierSpread: z.string(),
+    })
+        .optional(),
+    checks: z.array(CheckSchema),
+});

package/dist/vendor/@jinn-network/sdk/dist/plugins.d.ts

@@ -0,0 +1,36 @@
+export type SolverPluginSourceKind = 'bundled' | 'local' | 'npm' | 'git' | 'github' | 'claude';
+export type SolverPluginEntry = string | {
+    name?: string;
+    source: string;
+    version?: string;
+};
+export interface SolverPluginManifest {
+    name: string;
+    version: string;
+    description?: string;
+    jinn?: {
+        supports?: string[];
+        capabilities?: Record<string, unknown>;
+        mcpServers?: Record<string, unknown>;
+        skills?: string[];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface LoadedSolverPlugin {
+    name: string;
+    version: string;
+    supports: string[];
+    source: string;
+    sourceKind: SolverPluginSourceKind;
+    root: string;
+    manifestPath: string;
+    manifest: SolverPluginManifest;
+    sha256: string;
+    cid?: string;
+}
+export interface ResolveSolverPluginOptions {
+    bundledRoot?: string;
+    vendorRoot?: string;
+}
+export declare function validateSolverPluginManifest(input: unknown): SolverPluginManifest;

package/dist/vendor/@jinn-network/sdk/dist/plugins.js

@@ -0,0 +1,54 @@
+function assertRecord(value, label) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+}
+export function validateSolverPluginManifest(input) {
+    assertRecord(input, 'manifest');
+    for (const key of Object.keys(input)) {
+        if (key.startsWith('jinn.')) {
+            throw new Error(`unknown top-level jinn extension key: ${key}; use manifest.jinn`);
+        }
+    }
+    if (typeof input['name'] !== 'string' || input['name'].length === 0) {
+        throw new Error('manifest.name is required');
+    }
+    if (typeof input['version'] !== 'string' || input['version'].length === 0) {
+        throw new Error('manifest.version is required');
+    }
+    const jinn = input['jinn'];
+    if (jinn !== undefined) {
+        assertRecord(jinn, 'manifest.jinn');
+        if ('solverType' in jinn) {
+            throw new Error('manifest.jinn.solverType is no longer supported; SolverNet contracts define solverType authority');
+        }
+        if ('schemas' in jinn) {
+            throw new Error('manifest.jinn.schemas is no longer supported; SolverNet contracts define canonical schemas');
+        }
+        const supports = jinn['supports'];
+        if (supports !== undefined) {
+            if (!Array.isArray(supports))
+                throw new Error('manifest.jinn.supports must be an array');
+            for (const [idx, value] of supports.entries()) {
+                if (typeof value !== 'string' || value.length === 0) {
+                    throw new Error(`manifest.jinn.supports[${idx}] must be a non-empty string`);
+                }
+            }
+        }
+        if (jinn['capabilities'] !== undefined)
+            assertRecord(jinn['capabilities'], 'manifest.jinn.capabilities');
+        if (jinn['mcpServers'] !== undefined)
+            assertRecord(jinn['mcpServers'], 'manifest.jinn.mcpServers');
+        const skills = jinn['skills'];
+        if (skills !== undefined) {
+            if (!Array.isArray(skills))
+                throw new Error('manifest.jinn.skills must be an array');
+            for (const [idx, value] of skills.entries()) {
+                if (typeof value !== 'string' || value.length === 0) {
+                    throw new Error(`manifest.jinn.skills[${idx}] must be a non-empty string`);
+                }
+            }
+        }
+    }
+    return input;
+}