@jinn-network/client 0.1.2 → 0.1.3-canary.24b69ea4

package/dist/vendor/@jinn-network/sdk/dist/payloads/session-derived.d.ts

@@ -0,0 +1,359 @@
+import { z } from 'zod';
+export declare const SessionDerivedExpectedArtifactsSchema: z.ZodObject<{
+    finalPatchRef: z.ZodOptional<z.ZodString>;
+    testSuiteRef: z.ZodOptional<z.ZodString>;
+    reproductionRef: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    finalPatchRef: z.ZodOptional<z.ZodString>;
+    testSuiteRef: z.ZodOptional<z.ZodString>;
+    reproductionRef: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    finalPatchRef: z.ZodOptional<z.ZodString>;
+    testSuiteRef: z.ZodOptional<z.ZodString>;
+    reproductionRef: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const SessionDerivedTaskSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"session-derived-task.v1">;
+    sourceCaptureCid: z.ZodString;
+    sourceCaptureSha256: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodObject<{
+        remoteUrl: z.ZodOptional<z.ZodString>;
+        commitHash: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        remoteUrl?: string | undefined;
+        commitHash?: string | undefined;
+        branch?: string | undefined;
+    }, {
+        remoteUrl?: string | undefined;
+        commitHash?: string | undefined;
+        branch?: string | undefined;
+    }>>;
+    problemStatement: z.ZodString;
+    expectedArtifacts: z.ZodDefault<z.ZodObject<{
+        finalPatchRef: z.ZodOptional<z.ZodString>;
+        testSuiteRef: z.ZodOptional<z.ZodString>;
+        reproductionRef: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        finalPatchRef: z.ZodOptional<z.ZodString>;
+        testSuiteRef: z.ZodOptional<z.ZodString>;
+        reproductionRef: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        finalPatchRef: z.ZodOptional<z.ZodString>;
+        testSuiteRef: z.ZodOptional<z.ZodString>;
+        reproductionRef: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    signalHints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    distillation: z.ZodObject<{
+        promptSha256: z.ZodString;
+        model: z.ZodString;
+        distilledAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        promptSha256: string;
+        model: string;
+        distilledAt: string;
+    }, {
+        promptSha256: string;
+        model: string;
+        distilledAt: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "session-derived-task.v1";
+    sourceCaptureCid: string;
+    problemStatement: string;
+    expectedArtifacts: {
+        finalPatchRef?: string | undefined;
+        testSuiteRef?: string | undefined;
+        reproductionRef?: string | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    signalHints: string[];
+    distillation: {
+        promptSha256: string;
+        model: string;
+        distilledAt: string;
+    };
+    repo?: {
+        remoteUrl?: string | undefined;
+        commitHash?: string | undefined;
+        branch?: string | undefined;
+    } | undefined;
+    sourceCaptureSha256?: string | undefined;
+}, {
+    schemaVersion: "session-derived-task.v1";
+    sourceCaptureCid: string;
+    problemStatement: string;
+    distillation: {
+        promptSha256: string;
+        model: string;
+        distilledAt: string;
+    };
+    repo?: {
+        remoteUrl?: string | undefined;
+        commitHash?: string | undefined;
+        branch?: string | undefined;
+    } | undefined;
+    sourceCaptureSha256?: string | undefined;
+    expectedArtifacts?: z.objectInputType<{
+        finalPatchRef: z.ZodOptional<z.ZodString>;
+        testSuiteRef: z.ZodOptional<z.ZodString>;
+        reproductionRef: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    signalHints?: string[] | undefined;
+}>;
+export type SessionDerivedTask = z.infer<typeof SessionDerivedTaskSchema>;
+export declare const SessionDerivedSolutionSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"session-derived-solution.v1">;
+    patch: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        artifactType: z.ZodString;
+        cid: z.ZodString;
+        sha256: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        artifactType: string;
+        cid: string;
+        sha256?: string | undefined;
+    }, {
+        artifactType: string;
+        cid: string;
+        sha256?: string | undefined;
+    }>, "many">>;
+    rationale: z.ZodOptional<z.ZodString>;
+    trajectoryCid: z.ZodOptional<z.ZodString>;
+    cost: z.ZodOptional<z.ZodObject<{
+        totalUsd: z.ZodNumber;
+        llmUsd: z.ZodOptional<z.ZodNumber>;
+        toolUsd: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        totalUsd: number;
+        llmUsd?: number | undefined;
+        toolUsd?: number | undefined;
+    }, {
+        totalUsd: number;
+        llmUsd?: number | undefined;
+        toolUsd?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "session-derived-solution.v1";
+    artifacts: {
+        artifactType: string;
+        cid: string;
+        sha256?: string | undefined;
+    }[];
+    patch?: string | undefined;
+    cost?: {
+        totalUsd: number;
+        llmUsd?: number | undefined;
+        toolUsd?: number | undefined;
+    } | undefined;
+    rationale?: string | undefined;
+    trajectoryCid?: string | undefined;
+}, {
+    schemaVersion: "session-derived-solution.v1";
+    patch?: string | undefined;
+    cost?: {
+        totalUsd: number;
+        llmUsd?: number | undefined;
+        toolUsd?: number | undefined;
+    } | undefined;
+    artifacts?: {
+        artifactType: string;
+        cid: string;
+        sha256?: string | undefined;
+    }[] | undefined;
+    rationale?: string | undefined;
+    trajectoryCid?: string | undefined;
+}>, {
+    schemaVersion: "session-derived-solution.v1";
+    artifacts: {
+        artifactType: string;
+        cid: string;
+        sha256?: string | undefined;
+    }[];
+    patch?: string | undefined;
+    cost?: {
+        totalUsd: number;
+        llmUsd?: number | undefined;
+        toolUsd?: number | undefined;
+    } | undefined;
+    rationale?: string | undefined;
+    trajectoryCid?: string | undefined;
+}, {
+    schemaVersion: "session-derived-solution.v1";
+    patch?: string | undefined;
+    cost?: {
+        totalUsd: number;
+        llmUsd?: number | undefined;
+        toolUsd?: number | undefined;
+    } | undefined;
+    artifacts?: {
+        artifactType: string;
+        cid: string;
+        sha256?: string | undefined;
+    }[] | undefined;
+    rationale?: string | undefined;
+    trajectoryCid?: string | undefined;
+}>;
+export type SessionDerivedSolution = z.infer<typeof SessionDerivedSolutionSchema>;
+export declare const SessionDerivedSignalSchema: z.ZodObject<{
+    present: z.ZodBoolean;
+    score: z.ZodNumber;
+    weight: z.ZodNumber;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    score: number;
+    present: boolean;
+    weight: number;
+    reasoning?: string | undefined;
+}, {
+    score: number;
+    present: boolean;
+    weight: number;
+    reasoning?: string | undefined;
+}>;
+export declare const SessionDerivedVerdictSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"session-derived-verdict.v1">;
+    verdict: z.ZodEnum<["SCORED", "SKIPPED"]>;
+    compositeScore: z.ZodNumber;
+    signalBreakdown: z.ZodObject<{
+        testSuiteRerun: z.ZodObject<{
+            present: z.ZodBoolean;
+            score: z.ZodNumber;
+            weight: z.ZodNumber;
+            reasoning: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        }, {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        }>;
+        structuralSimilarity: z.ZodObject<{
+            present: z.ZodBoolean;
+            score: z.ZodNumber;
+            weight: z.ZodNumber;
+            reasoning: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        }, {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        }>;
+        llmJudge: z.ZodObject<{
+            present: z.ZodBoolean;
+            score: z.ZodNumber;
+            weight: z.ZodNumber;
+            reasoning: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        }, {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        testSuiteRerun: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+        structuralSimilarity: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+        llmJudge: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+    }, {
+        testSuiteRerun: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+        structuralSimilarity: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+        llmJudge: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+    }>;
+    evaluatorCostUsd: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "session-derived-verdict.v1";
+    verdict: "SCORED" | "SKIPPED";
+    compositeScore: number;
+    signalBreakdown: {
+        testSuiteRerun: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+        structuralSimilarity: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+        llmJudge: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+    };
+    evaluatorCostUsd: number;
+}, {
+    schemaVersion: "session-derived-verdict.v1";
+    verdict: "SCORED" | "SKIPPED";
+    compositeScore: number;
+    signalBreakdown: {
+        testSuiteRerun: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+        structuralSimilarity: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+        llmJudge: {
+            score: number;
+            present: boolean;
+            weight: number;
+            reasoning?: string | undefined;
+        };
+    };
+    evaluatorCostUsd?: number | undefined;
+}>;
+export type SessionDerivedVerdict = z.infer<typeof SessionDerivedVerdictSchema>;

package/dist/vendor/@jinn-network/sdk/dist/payloads/session-derived.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+const HexShaSchema = z.string().regex(/^[0-9a-f]{64}$/);
+export const SessionDerivedExpectedArtifactsSchema = z.object({
+    finalPatchRef: z.string().min(1).optional(),
+    testSuiteRef: z.string().min(1).optional(),
+    reproductionRef: z.string().min(1).optional(),
+}).passthrough();
+export const SessionDerivedTaskSchema = z.object({
+    schemaVersion: z.literal('session-derived-task.v1'),
+    sourceCaptureCid: z.string().min(1),
+    sourceCaptureSha256: HexShaSchema.optional(),
+    repo: z.object({
+        remoteUrl: z.string().min(1).optional(),
+        commitHash: z.string().regex(/^[0-9a-f]{40}$/).optional(),
+        branch: z.string().min(1).optional(),
+    }).optional(),
+    problemStatement: z.string().min(1),
+    expectedArtifacts: SessionDerivedExpectedArtifactsSchema.default({}),
+    signalHints: z.array(z.string().min(1)).default([]),
+    distillation: z.object({
+        promptSha256: HexShaSchema,
+        model: z.string().min(1),
+        distilledAt: z.string().datetime({ offset: true }),
+    }),
+});
+export const SessionDerivedSolutionSchema = z.object({
+    schemaVersion: z.literal('session-derived-solution.v1'),
+    patch: z.string().min(1).optional(),
+    artifacts: z.array(z.object({
+        artifactType: z.string().min(1),
+        cid: z.string().min(1),
+        sha256: HexShaSchema.optional(),
+    })).default([]),
+    rationale: z.string().min(1).optional(),
+    trajectoryCid: z.string().min(1).optional(),
+    cost: z.object({
+        totalUsd: z.number().nonnegative(),
+        llmUsd: z.number().nonnegative().optional(),
+        toolUsd: z.number().nonnegative().optional(),
+    }).optional(),
+}).refine((value) => value.patch !== undefined || value.artifacts.length > 0, {
+    message: 'session-derived Solution requires patch or artifacts',
+});
+export const SessionDerivedSignalSchema = z.object({
+    present: z.boolean(),
+    score: z.number().min(0).max(1),
+    weight: z.number().positive(),
+    reasoning: z.string().optional(),
+});
+export const SessionDerivedVerdictSchema = z.object({
+    schemaVersion: z.literal('session-derived-verdict.v1'),
+    verdict: z.enum(['SCORED', 'SKIPPED']),
+    compositeScore: z.number().min(0).max(1),
+    signalBreakdown: z.object({
+        testSuiteRerun: SessionDerivedSignalSchema,
+        structuralSimilarity: SessionDerivedSignalSchema,
+        llmJudge: SessionDerivedSignalSchema,
+    }),
+    evaluatorCostUsd: z.number().nonnegative().default(0),
+});

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

@@ -0,0 +1,110 @@
+/**
+ * SWE-rebench v2 Solution + Verdict payload schemas.
+ *
+ * Solution: the unified-diff patch the Solver's harness produced for the
+ * benchmark instance. The Solver does not pin or reference its own
+ * trajectory — the daemon's envelope-assembly path pins the trajectory
+ * to IPFS and references it via the envelope-level
+ * `SignedEnvelope.trajectory: TrajectoryRefSchema`. Keeping
+ * trajectory-pinning out of the Solution payload preserves the
+ * solver/daemon boundary (the Solver only knows what it can derive
+ * from its own work).
+ *
+ * Cost (operator-self-reported) is generalisable across SolverNets.
+ *
+ * Verdict: deterministic test-suite pass/fail + grading provenance. The
+ * test log is surfaced via the envelope's `artifacts[]` (with the
+ * pinned-blob CID in the artifact's metadata) rather than as a typed
+ * payload field, so daemon-derived IPFS provenance does not leak into
+ * the Verdict schema.
+ *
+ * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §3.2
+ */
+import { z } from 'zod';
+export declare const SweRebenchV2SolutionPayloadSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"swe-rebench-v2-solution.v1">;
+    /** Unified diff patch (git-format). */
+    patch: z.ZodString;
+    /**
+     * Operator-self-reported cost of producing this Solution. Optional; when
+     * present, contributes to the per-harness cost rollups. Generalisable
+     * across SolverNets — only `totalUsd` is required at v1.
+     */
+    cost: z.ZodOptional<z.ZodObject<{
+        totalUsd: z.ZodNumber;
+        breakdown: z.ZodOptional<z.ZodObject<{
+            llm: z.ZodOptional<z.ZodNumber>;
+            tools: z.ZodOptional<z.ZodNumber>;
+            other: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            llm?: number | undefined;
+            tools?: number | undefined;
+            other?: number | undefined;
+        }, {
+            llm?: number | undefined;
+            tools?: number | undefined;
+            other?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        totalUsd: number;
+        breakdown?: {
+            llm?: number | undefined;
+            tools?: number | undefined;
+            other?: number | undefined;
+        } | undefined;
+    }, {
+        totalUsd: number;
+        breakdown?: {
+            llm?: number | undefined;
+            tools?: number | undefined;
+            other?: number | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "swe-rebench-v2-solution.v1";
+    patch: string;
+    cost?: {
+        totalUsd: number;
+        breakdown?: {
+            llm?: number | undefined;
+            tools?: number | undefined;
+            other?: number | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    schemaVersion: "swe-rebench-v2-solution.v1";
+    patch: string;
+    cost?: {
+        totalUsd: number;
+        breakdown?: {
+            llm?: number | undefined;
+            tools?: number | undefined;
+            other?: number | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+export type SweRebenchV2SolutionPayload = z.infer<typeof SweRebenchV2SolutionPayloadSchema>;
+export declare const SweRebenchV2VerdictPayloadSchema: 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;
+}>;
+export type SweRebenchV2VerdictPayload = z.infer<typeof SweRebenchV2VerdictPayloadSchema>;

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

@@ -0,0 +1,58 @@
+/**
+ * SWE-rebench v2 Solution + Verdict payload schemas.
+ *
+ * Solution: the unified-diff patch the Solver's harness produced for the
+ * benchmark instance. The Solver does not pin or reference its own
+ * trajectory — the daemon's envelope-assembly path pins the trajectory
+ * to IPFS and references it via the envelope-level
+ * `SignedEnvelope.trajectory: TrajectoryRefSchema`. Keeping
+ * trajectory-pinning out of the Solution payload preserves the
+ * solver/daemon boundary (the Solver only knows what it can derive
+ * from its own work).
+ *
+ * Cost (operator-self-reported) is generalisable across SolverNets.
+ *
+ * Verdict: deterministic test-suite pass/fail + grading provenance. The
+ * test log is surfaced via the envelope's `artifacts[]` (with the
+ * pinned-blob CID in the artifact's metadata) rather than as a typed
+ * payload field, so daemon-derived IPFS provenance does not leak into
+ * the Verdict schema.
+ *
+ * Spec: docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §3.2
+ */
+import { z } from 'zod';
+export const SweRebenchV2SolutionPayloadSchema = z.object({
+    schemaVersion: z.literal('swe-rebench-v2-solution.v1'),
+    /** Unified diff patch (git-format). */
+    patch: z.string().min(1),
+    /**
+     * Operator-self-reported cost of producing this Solution. Optional; when
+     * present, contributes to the per-harness cost rollups. Generalisable
+     * across SolverNets — only `totalUsd` is required at v1.
+     */
+    cost: z
+        .object({
+        totalUsd: z.number().nonnegative(),
+        breakdown: z
+            .object({
+            llm: z.number().nonnegative().optional(),
+            tools: z.number().nonnegative().optional(),
+            other: z.number().nonnegative().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+});
+export const SweRebenchV2VerdictPayloadSchema = 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)]),
+    /**
+     * 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.boolean(),
+    /** Cost of running the evaluator on this Solution (USDC-equivalent). */
+    evaluator_cost_usd: z.number().nonnegative(),
+});

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;
+}