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

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

@@ -0,0 +1,317 @@
+import { PredictionV1TaskSchema } from './prediction-v1.js';
+import { PredictionV1RestorationPayloadSchema, PredictionV1VerdictPayloadSchema, } from './payloads/prediction-v1.js';
+import { SweRebenchV2TaskSchema } from './swe-rebench-v2.js';
+import { SweRebenchV2SolutionPayloadSchema, SweRebenchV2VerdictPayloadSchema, } from './payloads/swe-rebench-v2.js';
+import { SessionDerivedSolutionSchema, SessionDerivedTaskSchema, SessionDerivedVerdictSchema, } from './payloads/session-derived.js';
+import { zodToJsonSchema } from './json-schema.js';
+export const PREDICTION_V1_SOLVER_NET_CONTRACT = {
+    id: 'prediction',
+    version: 'v1',
+    name: 'Prediction',
+    schemas: {
+        task: {
+            zod: PredictionV1TaskSchema,
+            json: zodToJsonSchema(PredictionV1TaskSchema),
+        },
+        solution: {
+            zod: PredictionV1RestorationPayloadSchema,
+            json: zodToJsonSchema(PredictionV1RestorationPayloadSchema),
+        },
+        verdict: {
+            zod: PredictionV1VerdictPayloadSchema,
+            json: zodToJsonSchema(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,
+    },
+};
+export const SWE_REBENCH_V2_V1_SOLVER_NET_CONTRACT = {
+    id: 'swe-rebench-v2',
+    version: 'v1',
+    name: 'SWE-rebench v2',
+    schemas: {
+        task: {
+            zod: SweRebenchV2TaskSchema,
+            json: zodToJsonSchema(SweRebenchV2TaskSchema),
+        },
+        solution: {
+            zod: SweRebenchV2SolutionPayloadSchema,
+            json: zodToJsonSchema(SweRebenchV2SolutionPayloadSchema),
+        },
+        verdict: {
+            zod: SweRebenchV2VerdictPayloadSchema,
+            json: zodToJsonSchema(SweRebenchV2VerdictPayloadSchema),
+        },
+    },
+    claimPolicyDefaults: {
+        mode: 'parallel',
+        maxClaims: 50,
+        maxClaimsPerOperator: 5,
+        claimLeaseTtlSeconds: 60 * 60, // 1 hour per Task — coding tasks need more time than predictions
+    },
+    credentialRequirements: {
+        creator: [
+            {
+                id: 'huggingface.dataset.read',
+                kind: 'public-api',
+                required: true,
+                description: 'Read public HuggingFace dataset rows for Task creation (datasets-server.huggingface.co).',
+            },
+        ],
+        solver: [],
+        evaluator: [
+            {
+                id: 'docker.hub.swerebenchv2.read',
+                kind: 'public-api',
+                required: true,
+                description: 'Pull SWE-rebench v2 per-instance Docker images from docker.io/swerebenchv2.',
+            },
+        ],
+    },
+    evaluationFunction: {
+        id: 'swe-rebench-v2.docker-test-suite.v1',
+        deterministic: true,
+        inputs: ['SWE-rebench v2 Task', 'SWE-rebench v2 Solution', 'per-instance Docker image'],
+        output: 'SWE-rebench v2 Verdict',
+        implementation: 'client/src/harnesses/impls/swe-rebench-v2-evaluator',
+    },
+    aggregationFunction: {
+        id: 'swe-rebench-v2.multi-winrate.v1',
+        deterministic: true,
+        inputs: ['SCORED swe-rebench-v2.v1 Verdicts'],
+        output: 'structured network-result (mean/complexity-weighted/byLanguage/frontier/parityTrip)',
+        windowDays: 30,
+    },
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// SESSION_DERIVED_V1_SOLVER_NET_CONTRACT — Phase 0 / Task 0.4 scaffold.
+//
+// Contract identity + claim-policy + credential requirements + evaluator and
+// aggregation refs are landed here so downstream phases (task-generator,
+// composite evaluator, runtime plugin) can reference the contract without
+// circular blocking. Payload schemas (Task / Solution / Verdict) are
+// placeholders; they get filled in Phase 10 of the plan once the LLM-distilled
+// payload shapes are nailed down.
+//
+// Spec: spec/2026-05-07-telemetry-collector-and-task-generator.md §5.1, §5.2.
+// ─────────────────────────────────────────────────────────────────────────────
+export const SESSION_DERIVED_V1_SOLVER_NET_CONTRACT = {
+    id: 'session-derived',
+    version: 'v1',
+    name: 'Session-derived',
+    schemas: {
+        task: {
+            zod: SessionDerivedTaskSchema,
+            json: zodToJsonSchema(SessionDerivedTaskSchema),
+        },
+        solution: {
+            zod: SessionDerivedSolutionSchema,
+            json: zodToJsonSchema(SessionDerivedSolutionSchema),
+        },
+        verdict: {
+            zod: SessionDerivedVerdictSchema,
+            json: zodToJsonSchema(SessionDerivedVerdictSchema),
+        },
+    },
+    claimPolicyDefaults: {
+        mode: 'parallel',
+        maxClaims: 50,
+        maxClaimsPerOperator: 5,
+        claimLeaseTtlSeconds: 4 * 60 * 60, // 4h per Task — sessions can be larger than swe-rebench-v2's 1h tasks
+    },
+    credentialRequirements: {
+        creator: [],
+        solver: [],
+        evaluator: [
+            {
+                // Spec §5.2: evaluators require a $50 USDC bond to participate.
+                // The bond mechanism itself is a separate workstream; this entry
+                // declares the requirement so manifest-side registration can flag
+                // operators who have not yet posted bond.
+                id: 'session-derived.evaluator.bond',
+                kind: 'operator-credential',
+                required: true,
+                description: 'Evaluators must post a $50 USDC bond (slashable on detected dishonesty) to participate in session-derived evaluation.',
+            },
+        ],
+    },
+    evaluationFunction: {
+        id: '@jinn-network/session-derived-evaluator',
+        deterministic: false, // composite uses LLM-judge component → non-deterministic
+        inputs: ['session-derived Task', 'session-derived Solution', 'sourceCapture envelope'],
+        output: 'session-derived Verdict (composite_score + signal_breakdown)',
+        implementation: 'client/src/harnesses/impls/session-derived-evaluator', // Phase 10 surface
+    },
+    aggregationFunction: {
+        id: 'session-derived-rolling-mean',
+        deterministic: false,
+        inputs: ['SCORED session-derived Verdicts'],
+        output: 'session-derived-network-result (mean composite + signal-coverage breakdown)',
+        windowDays: 30,
+    },
+};
+export const SOLVER_NET_CONTRACTS = {
+    'prediction.v1': PREDICTION_V1_SOLVER_NET_CONTRACT,
+    'swe-rebench-v2.v1': SWE_REBENCH_V2_V1_SOLVER_NET_CONTRACT,
+    'session-derived.v1': SESSION_DERIVED_V1_SOLVER_NET_CONTRACT,
+};
+/**
+ * Look up a SolverNet contract template by stable identity ({id, version}).
+ *
+ * The legacy string-keyed signature (`getSolverNetContract('prediction.v1')`)
+ * was removed in Task 30 of `spec/2026-05-05-solvernet-creation-and-launch.md`
+ * alongside `SolverNetContract.solverType`.
+ */
+export function getSolverNetContract(ref) {
+    const key = `${ref.id}.${ref.version}`;
+    return SOLVER_NET_CONTRACTS[key];
+}
+/**
+ * Internal helper: derives the legacy `solverType` string (`${id}.${version}`)
+ * from a contract id and version.
+ *
+ * @internal Used only by daemon-internal harness dispatch's compatibility
+ * layer (spec §15 non-goal: the internal `solverType` alias in harness
+ * dispatch is intentionally retained for one cycle past Task 30). NOT
+ * re-exported from the `@jinn-network/sdk/solvernets` barrel and not part
+ * of the SDK's public surface.
+ */
+export function solverTypeAlias(ref) {
+    return `${ref.id}.${ref.version}`;
+}
+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 parseSolverTypeString(solverType) {
+    const dot = solverType.lastIndexOf('.');
+    if (dot <= 0 || dot === solverType.length - 1)
+        return undefined;
+    return { id: solverType.slice(0, dot), version: solverType.slice(dot + 1) };
+}
+function getSchema(solverType, kind) {
+    const ref = parseSolverTypeString(solverType);
+    if (!ref)
+        return undefined;
+    return getSolverNetContract(ref)?.schemas[kind].zod;
+}
+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,120 @@
+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;
+    /**
+     * Harness execution mode.
+     *
+     * - `'train'` (default): learning mode. The harness's Improve / Memory
+     *   phases (or equivalent writeback paths in a Path 2 harness) run;
+     *   `implStateDir` mutates as the harness accumulates experience;
+     *   `Executor.codeDigest` changes after each Task. Substrate-flow
+     *   contributor.
+     *
+     * - `'frozen'`: evaluation mode. The harness MUST NOT write to
+     *   `implStateDir`. State is read-only; `codeDigest` is stable across
+     *   the entire frozen window. Verdicts on Solutions produced in this
+     *   mode accumulate under a single `(implName, version, codeDigest)`
+     *   identity, producing a clean benchmark score directly comparable to
+     *   traditional harness leaderboards (OpenHands, SWE-Agent, Aider, etc).
+     *
+     * The protocol enforces the freeze contract via the daemon-side
+     * hash-fence (the daemon hashes implStateDir before and after each Task
+     * and rejects envelopes where the hash changed in frozen mode).
+     * Path 2 harness implementations MUST gate writes on `mode === 'train'`;
+     * the SDK provides `requireTrain(ctx, action)` as an opt-in helper at
+     * write call sites.
+     *
+     * See docs/superpowers/specs/2026-05-06-agent-harness-solvernet-design.md §6
+     * for the full design (trust stack, daemon enforcement, verified vs
+     * unverified frozen credibility tier).
+     */
+    mode: 'train' | 'frozen';
+}
+/**
+ * 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;
+/**
+ * Error thrown by SDK helpers when a harness violates an invariant.
+ * Path 2 harness implementations may catch this to surface a typed error
+ * to the daemon's task handler.
+ */
+export declare class HarnessError extends Error {
+    constructor(message: string);
+}
+/**
+ * Throws if the harness is in frozen mode. Use at write call sites in
+ * Path 2 harness implementations to assert that a write to implStateDir
+ * is only happening in train mode.
+ *
+ * @example
+ *   requireTrain(ctx, 'update constitutional state');
+ *   await fs.writeFile(constitutionPath, serialized);
+ *
+ * The daemon's hash-fence catches violations regardless of whether
+ * `requireTrain` is used; this helper is purely for defensive ergonomics
+ * at the harness implementation layer (fail fast at the call site rather
+ * than after the Task completes).
+ */
+export declare function requireTrain(ctx: HarnessContext, action: string): void;

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

@@ -0,0 +1,31 @@
+export { REQUIRES_LIVE_DAEMON_READINESS, SkippableError } from './types.js';
+/**
+ * Error thrown by SDK helpers when a harness violates an invariant.
+ * Path 2 harness implementations may catch this to surface a typed error
+ * to the daemon's task handler.
+ */
+export class HarnessError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'HarnessError';
+    }
+}
+/**
+ * Throws if the harness is in frozen mode. Use at write call sites in
+ * Path 2 harness implementations to assert that a write to implStateDir
+ * is only happening in train mode.
+ *
+ * @example
+ *   requireTrain(ctx, 'update constitutional state');
+ *   await fs.writeFile(constitutionPath, serialized);
+ *
+ * The daemon's hash-fence catches violations regardless of whether
+ * `requireTrain` is used; this helper is purely for defensive ergonomics
+ * at the harness implementation layer (fail fast at the call site rather
+ * than after the Task completes).
+ */
+export function requireTrain(ctx, action) {
+    if (ctx.mode === 'frozen') {
+        throw new HarnessError(`Cannot ${action} in frozen mode. Gate this write on ctx.mode === 'train'.`);
+    }
+}

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

@@ -0,0 +1,4 @@
+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 { SessionDerivedExpectedArtifactsSchema, SessionDerivedSignalSchema, SessionDerivedSolutionSchema, SessionDerivedTaskSchema, SessionDerivedVerdictSchema, type SessionDerivedSolution, type SessionDerivedTask, type SessionDerivedVerdict, } from './payloads/session-derived.js';
+export { SESSION_DERIVED_DISTILL_PROMPT_V1, SESSION_DERIVED_DISTILL_PROMPT_V1_SHA256, } from './session-derived/distill-prompt-v1.js';

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

@@ -0,0 +1,7 @@
+// @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';
+export { SessionDerivedExpectedArtifactsSchema, SessionDerivedSignalSchema, SessionDerivedSolutionSchema, SessionDerivedTaskSchema, SessionDerivedVerdictSchema, } from './payloads/session-derived.js';
+export { SESSION_DERIVED_DISTILL_PROMPT_V1, SESSION_DERIVED_DISTILL_PROMPT_V1_SHA256, } from './session-derived/distill-prompt-v1.js';

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/**
+ * Canonical JSON Schema body. We use a permissive object alias rather than a
+ * strict type because manifests carry arbitrary user-authored schemas and the
+ * SDK does not need to constrain their internal shape — JSON Schema is
+ * already a self-describing format.
+ *
+ * Use `unknown`-typed access (or a parser like Ajv) when reading nested fields.
+ */
+export type JsonSchema = Record<string, unknown>;
+/**
+ * Serialize a Zod schema to canonical JSON Schema (draft-07).
+ *
+ * Strips the top-level `$schema` reference so the returned object is a
+ * plain schema body ready for embedding in a manifest. Manifest readers
+ * who need the draft annotation can re-add it.
+ */
+export declare function zodToJsonSchema(schema: z.ZodTypeAny): JsonSchema;
+/**
+ * Reverse direction: produce a Zod validator from a JSON Schema body.
+ *
+ * Day-1 implementation handles the JSON Schema constructs produced by
+ * `zodToJsonSchema` for the manifest shape (objects, strings, numbers,
+ * integers, booleans, enums, arrays, optional/required, basic unions via
+ * `anyOf`). It is sufficient to validate manifests authored by SDK users
+ * but does NOT promise full draft-07 coverage. Unknown constructs fall
+ * back to `z.unknown()` rather than throwing.
+ *
+ * For exhaustive draft-07 coverage in future, replace the body with a
+ * dependency such as `json-schema-to-zod` or wire Ajv directly.
+ */
+export declare function jsonSchemaToZod(schema: JsonSchema): z.ZodTypeAny;

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

@@ -0,0 +1,131 @@
+// JSON Schema serialization helpers for the SDK.
+//
+// SolverNet manifests carry schemas in canonical JSON Schema form (the wire
+// format), but daemon-side code prefers Zod for ergonomic validation.
+// `zodToJsonSchema` produces the canonical form for inclusion in manifests;
+// `jsonSchemaToZod` recovers a Zod validator from a JSON Schema body for
+// cases where the manifest is the only available source (e.g., parsing an
+// externally-launched SolverNet manifest into a runnable validator).
+//
+// See `spec/2026-05-05-solvernet-creation-and-launch.md` §7 and §8.
+import { z } from 'zod';
+import { zodToJsonSchema as zodToJsonSchemaImpl } from 'zod-to-json-schema';
+/**
+ * Serialize a Zod schema to canonical JSON Schema (draft-07).
+ *
+ * Strips the top-level `$schema` reference so the returned object is a
+ * plain schema body ready for embedding in a manifest. Manifest readers
+ * who need the draft annotation can re-add it.
+ */
+export function zodToJsonSchema(schema) {
+    // Default target is jsonSchema7. We omit `$schema` to keep the embedded
+    // shape minimal — the manifest schemaVersion frames the dialect.
+    const { $schema: _$schema, ...body } = zodToJsonSchemaImpl(schema, {
+        $refStrategy: 'none',
+    });
+    return body;
+}
+/**
+ * Reverse direction: produce a Zod validator from a JSON Schema body.
+ *
+ * Day-1 implementation handles the JSON Schema constructs produced by
+ * `zodToJsonSchema` for the manifest shape (objects, strings, numbers,
+ * integers, booleans, enums, arrays, optional/required, basic unions via
+ * `anyOf`). It is sufficient to validate manifests authored by SDK users
+ * but does NOT promise full draft-07 coverage. Unknown constructs fall
+ * back to `z.unknown()` rather than throwing.
+ *
+ * For exhaustive draft-07 coverage in future, replace the body with a
+ * dependency such as `json-schema-to-zod` or wire Ajv directly.
+ */
+export function jsonSchemaToZod(schema) {
+    return convert(schema);
+}
+function convert(schema) {
+    if (typeof schema !== 'object' || schema === null) {
+        return z.unknown();
+    }
+    const s = schema;
+    // anyOf / oneOf -> z.union (need >= 2 members for z.union; fall back).
+    if (Array.isArray(s.anyOf) || Array.isArray(s.oneOf)) {
+        const branches = (s.anyOf ?? s.oneOf);
+        if (branches.length === 0)
+            return z.unknown();
+        if (branches.length === 1)
+            return convert(branches[0]);
+        const zodBranches = branches.map((b) => convert(b));
+        return z.union(zodBranches);
+    }
+    // Enum (string-typed enums are by far the common case in our manifests).
+    if (Array.isArray(s.enum) && s.enum.length > 0) {
+        const allStrings = s.enum.every((v) => typeof v === 'string');
+        if (allStrings) {
+            const values = s.enum;
+            if (values.length === 1) {
+                return z.literal(values[0]);
+            }
+            return z.enum(values);
+        }
+        // Mixed-type enum: union of literals.
+        const literals = s.enum.map((v) => {
+            if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
+                return z.literal(v);
+            }
+            return z.unknown();
+        });
+        if (literals.length < 2)
+            return literals[0] ?? z.unknown();
+        return z.union(literals);
+    }
+    // const (single-value literal).
+    if (s.const !== undefined) {
+        const v = s.const;
+        if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
+            return z.literal(v);
+        }
+        return z.unknown();
+    }
+    switch (s.type) {
+        case 'string':
+            return z.string();
+        case 'integer':
+            return z.number().int();
+        case 'number':
+            return z.number();
+        case 'boolean':
+            return z.boolean();
+        case 'null':
+            return z.null();
+        case 'array': {
+            const items = s.items ? convert(s.items) : z.unknown();
+            return z.array(items);
+        }
+        case 'object': {
+            const props = s.properties ?? {};
+            const required = new Set(s.required ?? []);
+            const shape = {};
+            for (const [key, child] of Object.entries(props)) {
+                const childZod = convert(child);
+                shape[key] = required.has(key) ? childZod : childZod.optional();
+            }
+            const obj = z.object(shape);
+            // Default zod-to-json-schema emits additionalProperties: false; we
+            // honor that by leaving the object strict-ish (passthrough by default).
+            // Use `.passthrough()` if additionalProperties is true or unset to
+            // match permissive JSON Schema semantics.
+            //
+            // Note: `zodToJsonSchema` emits `additionalProperties: false` by default
+            // for `z.object()` (passthrough is opt-in), so a round-trip through this
+            // helper turns non-strict objects into strict ones. Day-1 acceptable;
+            // flag here in case downstream callers need passthrough semantics
+            // preserved.
+            if (s.additionalProperties === false) {
+                return obj.strict();
+            }
+            return obj.passthrough();
+        }
+        default:
+            // Type missing or unrecognized: fall back to unknown.
+            return z.unknown();
+    }
+}