openpond-sdk 0.12.26 → 0.12.27

package/dist/types/packages/sdk/src/weight-space-programming.d.ts

@@ -0,0 +1,845 @@
+import { z } from "zod";
+export declare const WeightSpaceHashSchema: z.ZodString;
+export declare const WeightSpaceIdSchema: z.ZodString;
+export declare const WEIGHT_SPACE_MAX_PATCH_BYTES = 16777216;
+/** One exact dense implementation. Catalog membership alone cannot enable it. */
+export declare const WeightSpaceModelSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+    modelId: z.ZodString;
+    revision: z.ZodString;
+    configHash: z.ZodString;
+    weightsHash: z.ZodString;
+    tokenizerHash: z.ZodString;
+    weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+    architecture: z.ZodLiteral<"dense_decoder">;
+    dtype: z.ZodEnum<{
+        bfloat16: "bfloat16";
+        float16: "float16";
+        float32: "float32";
+    }>;
+    quantization: z.ZodLiteral<"none">;
+    adapter: z.ZodNull;
+    hiddenSize: z.ZodNumber;
+    intermediateSizes: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const WeightSpaceLimitsSchema: z.ZodObject<{
+    maximumDurationSeconds: z.ZodNumber;
+    maximumIdleSeconds: z.ZodNumber;
+    maximumCommands: z.ZodNumber;
+    maximumCandidates: z.ZodNumber;
+    maximumPatchColumns: z.ZodNumber;
+    maximumTensorElements: z.ZodNumber;
+    maximumReturnedValues: z.ZodNumber;
+    maximumArithmeticWork: z.ZodNumber;
+    maximumForwardTokenWork: z.ZodNumber;
+    maximumCheckpointBytes: z.ZodNumber;
+}, z.core.$strict>;
+export type WeightSpaceLimits = z.infer<typeof WeightSpaceLimitsSchema>;
+export declare const WeightSpacePromptSchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    system: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const WeightSpacePanelSchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>;
+    role: z.ZodEnum<{
+        development: "development";
+        preservation: "preservation";
+    }>;
+    prompts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        system: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const WeightSpaceRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceRequest.v1">;
+    model: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodString;
+        configHash: z.ZodString;
+        weightsHash: z.ZodString;
+        tokenizerHash: z.ZodString;
+        weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+        architecture: z.ZodLiteral<"dense_decoder">;
+        dtype: z.ZodEnum<{
+            bfloat16: "bfloat16";
+            float16: "float16";
+            float32: "float32";
+        }>;
+        quantization: z.ZodLiteral<"none">;
+        adapter: z.ZodNull;
+        hiddenSize: z.ZodNumber;
+        intermediateSizes: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>;
+    teacher: z.ZodObject<{
+        controller: z.ZodLiteral<"local_agent">;
+        providerId: z.ZodString;
+        modelId: z.ZodString;
+        sessionId: z.ZodString;
+    }, z.core.$strict>;
+    objective: z.ZodString;
+    panels: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        role: z.ZodEnum<{
+            development: "development";
+            preservation: "preservation";
+        }>;
+        prompts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+            system: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    frozenEvaluation: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>;
+    generation: z.ZodObject<{
+        maxOutputTokens: z.ZodNumber;
+        seed: z.ZodNumber;
+        sampling: z.ZodLiteral<"greedy_v1">;
+    }, z.core.$strict>;
+    limits: z.ZodObject<{
+        maximumDurationSeconds: z.ZodNumber;
+        maximumIdleSeconds: z.ZodNumber;
+        maximumCommands: z.ZodNumber;
+        maximumCandidates: z.ZodNumber;
+        maximumPatchColumns: z.ZodNumber;
+        maximumTensorElements: z.ZodNumber;
+        maximumReturnedValues: z.ZodNumber;
+        maximumArithmeticWork: z.ZodNumber;
+        maximumForwardTokenWork: z.ZodNumber;
+        maximumCheckpointBytes: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type WeightSpaceRequest = z.infer<typeof WeightSpaceRequestSchema>;
+/** Resolved by the evaluation owner, never supplied as an editing command.
+ * Only policy-visible inputs cross into the tensor process. Graders and private
+ * expected outputs stay with the scoring owner. */
+export declare const WeightSpaceFrozenPanelSchema: z.ZodObject<{
+    source: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    prompts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        system: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WeightSpaceFrozenPanel = z.infer<typeof WeightSpaceFrozenPanelSchema>;
+export declare const WeightSpaceColumnsSchema: z.ZodObject<{
+    layer: z.ZodNumber;
+    columns: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>;
+/** A numerical program, not Python source. No imports, file/network access,
+ * autograd, optimization or hidden forward passes are expressible here. */
+export declare const WeightSpaceInstructionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"read_tensor">;
+    out: z.ZodString;
+    name: z.ZodString;
+    source: z.ZodEnum<{
+        base: "base";
+        candidate: "candidate";
+    }>;
+    ranges: z.ZodArray<z.ZodObject<{
+        start: z.ZodNumber;
+        stop: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    layer: z.ZodNumber;
+    columns: z.ZodArray<z.ZodNumber>;
+    op: z.ZodLiteral<"read">;
+    out: z.ZodString;
+    source: z.ZodEnum<{
+        base: "base";
+        candidate: "candidate";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"literal">;
+    out: z.ZodString;
+    shape: z.ZodArray<z.ZodNumber>;
+    values: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"scale">;
+    out: z.ZodString;
+    input: z.ZodString;
+    factor: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodEnum<{
+        add: "add";
+        matmul: "matmul";
+        subtract: "subtract";
+    }>;
+    out: z.ZodString;
+    left: z.ZodString;
+    right: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodEnum<{
+        mean_columns: "mean_columns";
+        normalize_columns: "normalize_columns";
+        singular_vectors: "singular_vectors";
+        transpose: "transpose";
+    }>;
+    out: z.ZodString;
+    input: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"slice">;
+    out: z.ZodString;
+    input: z.ZodString;
+    axis: z.ZodNumber;
+    start: z.ZodNumber;
+    stop: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    layer: z.ZodNumber;
+    columns: z.ZodArray<z.ZodNumber>;
+    op: z.ZodLiteral<"write">;
+    input: z.ZodString;
+}, z.core.$strict>], "op">;
+export declare const WeightSpaceProgramSchema: z.ZodObject<{
+    instructions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"read_tensor">;
+        out: z.ZodString;
+        name: z.ZodString;
+        source: z.ZodEnum<{
+            base: "base";
+            candidate: "candidate";
+        }>;
+        ranges: z.ZodArray<z.ZodObject<{
+            start: z.ZodNumber;
+            stop: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        layer: z.ZodNumber;
+        columns: z.ZodArray<z.ZodNumber>;
+        op: z.ZodLiteral<"read">;
+        out: z.ZodString;
+        source: z.ZodEnum<{
+            base: "base";
+            candidate: "candidate";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"literal">;
+        out: z.ZodString;
+        shape: z.ZodArray<z.ZodNumber>;
+        values: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"scale">;
+        out: z.ZodString;
+        input: z.ZodString;
+        factor: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodEnum<{
+            add: "add";
+            matmul: "matmul";
+            subtract: "subtract";
+        }>;
+        out: z.ZodString;
+        left: z.ZodString;
+        right: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodEnum<{
+            mean_columns: "mean_columns";
+            normalize_columns: "normalize_columns";
+            singular_vectors: "singular_vectors";
+            transpose: "transpose";
+        }>;
+        out: z.ZodString;
+        input: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"slice">;
+        out: z.ZodString;
+        input: z.ZodString;
+        axis: z.ZodNumber;
+        start: z.ZodNumber;
+        stop: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        layer: z.ZodNumber;
+        columns: z.ZodArray<z.ZodNumber>;
+        op: z.ZodLiteral<"write">;
+        input: z.ZodString;
+    }, z.core.$strict>], "op">>;
+    returns: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type WeightSpaceProgram = z.infer<typeof WeightSpaceProgramSchema>;
+export declare const WeightSpaceCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    teamId: z.ZodString;
+    sessionId: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    candidateHash: z.ZodString;
+    action: z.ZodLiteral<"catalog">;
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    layer: z.ZodNumber;
+    columns: z.ZodArray<z.ZodNumber>;
+    teamId: z.ZodString;
+    sessionId: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    candidateHash: z.ZodString;
+    action: z.ZodLiteral<"inspect">;
+}, z.core.$strict>, z.ZodObject<{
+    teamId: z.ZodString;
+    sessionId: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    candidateHash: z.ZodString;
+    action: z.ZodLiteral<"program">;
+    program: z.ZodObject<{
+        instructions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            op: z.ZodLiteral<"read_tensor">;
+            out: z.ZodString;
+            name: z.ZodString;
+            source: z.ZodEnum<{
+                base: "base";
+                candidate: "candidate";
+            }>;
+            ranges: z.ZodArray<z.ZodObject<{
+                start: z.ZodNumber;
+                stop: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            layer: z.ZodNumber;
+            columns: z.ZodArray<z.ZodNumber>;
+            op: z.ZodLiteral<"read">;
+            out: z.ZodString;
+            source: z.ZodEnum<{
+                base: "base";
+                candidate: "candidate";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"literal">;
+            out: z.ZodString;
+            shape: z.ZodArray<z.ZodNumber>;
+            values: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"scale">;
+            out: z.ZodString;
+            input: z.ZodString;
+            factor: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodEnum<{
+                add: "add";
+                matmul: "matmul";
+                subtract: "subtract";
+            }>;
+            out: z.ZodString;
+            left: z.ZodString;
+            right: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodEnum<{
+                mean_columns: "mean_columns";
+                normalize_columns: "normalize_columns";
+                singular_vectors: "singular_vectors";
+                transpose: "transpose";
+            }>;
+            out: z.ZodString;
+            input: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"slice">;
+            out: z.ZodString;
+            input: z.ZodString;
+            axis: z.ZodNumber;
+            start: z.ZodNumber;
+            stop: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            layer: z.ZodNumber;
+            columns: z.ZodArray<z.ZodNumber>;
+            op: z.ZodLiteral<"write">;
+            input: z.ZodString;
+        }, z.core.$strict>], "op">>;
+        returns: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    hypothesis: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    teamId: z.ZodString;
+    sessionId: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    candidateHash: z.ZodString;
+    action: z.ZodLiteral<"code">;
+    code: z.ZodString;
+    hypothesis: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    teamId: z.ZodString;
+    sessionId: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    candidateHash: z.ZodString;
+    action: z.ZodLiteral<"evaluate">;
+    panelId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    teamId: z.ZodString;
+    sessionId: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    candidateHash: z.ZodString;
+    action: z.ZodLiteral<"select">;
+    targetCandidateHash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    teamId: z.ZodString;
+    sessionId: z.ZodString;
+    operationId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    candidateHash: z.ZodString;
+    action: z.ZodLiteral<"finalize">;
+}, z.core.$strict>], "action">;
+export type WeightSpaceCommand = z.infer<typeof WeightSpaceCommandSchema>;
+export declare const WeightSpaceTensorSummarySchema: z.ZodObject<{
+    shape: z.ZodArray<z.ZodNumber>;
+    minimum: z.ZodNumber;
+    maximum: z.ZodNumber;
+    mean: z.ZodNumber;
+    norm: z.ZodNumber;
+    values: z.ZodArray<z.ZodNumber>;
+    truncated: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const WeightSpaceEvaluationSchema: z.ZodObject<{
+    panelId: z.ZodString;
+    role: z.ZodEnum<{
+        development: "development";
+        preservation: "preservation";
+    }>;
+    candidateHash: z.ZodString;
+    sampling: z.ZodLiteral<"greedy_v1">;
+    seed: z.ZodNumber;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        inputHash: z.ZodString;
+        outputIds: z.ZodArray<z.ZodNumber>;
+        outputText: z.ZodString;
+        reachedTokenLimit: z.ZodBoolean;
+        forwardTokenWork: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const WeightSpaceFrozenEvaluationSchema: z.ZodObject<{
+    panelId: z.ZodString;
+    candidateHash: z.ZodString;
+    sampling: z.ZodLiteral<"greedy_v1">;
+    seed: z.ZodNumber;
+    rows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        inputHash: z.ZodString;
+        outputIds: z.ZodArray<z.ZodNumber>;
+        outputText: z.ZodString;
+        reachedTokenLimit: z.ZodBoolean;
+        forwardTokenWork: z.ZodNumber;
+    }, z.core.$strict>>;
+    role: z.ZodLiteral<"frozen">;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    baseline: z.ZodObject<{
+        candidateHash: z.ZodString;
+        rows: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            inputHash: z.ZodString;
+            outputIds: z.ZodArray<z.ZodNumber>;
+            outputText: z.ZodString;
+            reachedTokenLimit: z.ZodBoolean;
+            forwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Shared by the authoritative result owner and portable consumers. Token work
+ * is full attended context per forward, even when inference uses a KV cache. */
+export declare function verifyWeightSpaceEvaluation(value: z.infer<typeof WeightSpaceEvaluationSchema> | z.infer<typeof WeightSpaceFrozenEvaluationSchema>, request: WeightSpaceRequest, panel: {
+    id: string;
+    role: "development" | "preservation" | "frozen";
+    prompts: z.infer<typeof WeightSpacePromptSchema>[];
+}, candidateHash: string): Promise<{
+    panelId: string;
+    role: "development" | "preservation";
+    candidateHash: string;
+    sampling: "greedy_v1";
+    seed: number;
+    rows: {
+        id: string;
+        inputHash: string;
+        outputIds: number[];
+        outputText: string;
+        reachedTokenLimit: boolean;
+        forwardTokenWork: number;
+    }[];
+} | {
+    panelId: string;
+    candidateHash: string;
+    sampling: "greedy_v1";
+    seed: number;
+    rows: {
+        id: string;
+        inputHash: string;
+        outputIds: number[];
+        outputText: string;
+        reachedTokenLimit: boolean;
+        forwardTokenWork: number;
+    }[];
+    role: "frozen";
+    source: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    };
+    baseline: {
+        candidateHash: string;
+        rows: {
+            id: string;
+            inputHash: string;
+            outputIds: number[];
+            outputText: string;
+            reachedTokenLimit: boolean;
+            forwardTokenWork: number;
+        }[];
+    };
+}>;
+export declare const WeightSpaceCommandResultContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandResult.v1">;
+    sessionId: z.ZodString;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    revision: z.ZodNumber;
+    parentCandidateHash: z.ZodString;
+    candidateHash: z.ZodString;
+    changedColumns: z.ZodArray<z.ZodObject<{
+        layer: z.ZodNumber;
+        columns: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        rejected: "rejected";
+        succeeded: "succeeded";
+    }>;
+    code: z.ZodNullable<z.ZodString>;
+    catalog: z.ZodNullable<z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            shape: z.ZodArray<z.ZodNumber>;
+            dtype: z.ZodLiteral<"BF16">;
+            editable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        nextOffset: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    tensors: z.ZodRecord<z.ZodString, z.ZodObject<{
+        shape: z.ZodArray<z.ZodNumber>;
+        minimum: z.ZodNumber;
+        maximum: z.ZodNumber;
+        mean: z.ZodNumber;
+        norm: z.ZodNumber;
+        values: z.ZodArray<z.ZodNumber>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    evaluation: z.ZodNullable<z.ZodObject<{
+        panelId: z.ZodString;
+        role: z.ZodEnum<{
+            development: "development";
+            preservation: "preservation";
+        }>;
+        candidateHash: z.ZodString;
+        sampling: z.ZodLiteral<"greedy_v1">;
+        seed: z.ZodNumber;
+        rows: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            inputHash: z.ZodString;
+            outputIds: z.ZodArray<z.ZodNumber>;
+            outputText: z.ZodString;
+            reachedTokenLimit: z.ZodBoolean;
+            forwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    finalEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        panelId: z.ZodString;
+        candidateHash: z.ZodString;
+        sampling: z.ZodLiteral<"greedy_v1">;
+        seed: z.ZodNumber;
+        rows: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            inputHash: z.ZodString;
+            outputIds: z.ZodArray<z.ZodNumber>;
+            outputText: z.ZodString;
+            reachedTokenLimit: z.ZodBoolean;
+            forwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>>;
+        role: z.ZodLiteral<"frozen">;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        baseline: z.ZodObject<{
+            candidateHash: z.ZodString;
+            rows: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                inputHash: z.ZodString;
+                outputIds: z.ZodArray<z.ZodNumber>;
+                outputText: z.ZodString;
+                reachedTokenLimit: z.ZodBoolean;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    usage: z.ZodObject<{
+        commands: z.ZodNumber;
+        candidates: z.ZodNumber;
+        arithmeticWork: z.ZodNumber;
+        forwardTokenWork: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const WeightSpaceCommandResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.weightSpaceCommandResult.v1">;
+    sessionId: z.ZodString;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    revision: z.ZodNumber;
+    parentCandidateHash: z.ZodString;
+    candidateHash: z.ZodString;
+    changedColumns: z.ZodArray<z.ZodObject<{
+        layer: z.ZodNumber;
+        columns: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        rejected: "rejected";
+        succeeded: "succeeded";
+    }>;
+    code: z.ZodNullable<z.ZodString>;
+    catalog: z.ZodNullable<z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            shape: z.ZodArray<z.ZodNumber>;
+            dtype: z.ZodLiteral<"BF16">;
+            editable: z.ZodBoolean;
+        }, z.core.$strict>>;
+        nextOffset: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    tensors: z.ZodRecord<z.ZodString, z.ZodObject<{
+        shape: z.ZodArray<z.ZodNumber>;
+        minimum: z.ZodNumber;
+        maximum: z.ZodNumber;
+        mean: z.ZodNumber;
+        norm: z.ZodNumber;
+        values: z.ZodArray<z.ZodNumber>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    evaluation: z.ZodNullable<z.ZodObject<{
+        panelId: z.ZodString;
+        role: z.ZodEnum<{
+            development: "development";
+            preservation: "preservation";
+        }>;
+        candidateHash: z.ZodString;
+        sampling: z.ZodLiteral<"greedy_v1">;
+        seed: z.ZodNumber;
+        rows: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            inputHash: z.ZodString;
+            outputIds: z.ZodArray<z.ZodNumber>;
+            outputText: z.ZodString;
+            reachedTokenLimit: z.ZodBoolean;
+            forwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    finalEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        panelId: z.ZodString;
+        candidateHash: z.ZodString;
+        sampling: z.ZodLiteral<"greedy_v1">;
+        seed: z.ZodNumber;
+        rows: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            inputHash: z.ZodString;
+            outputIds: z.ZodArray<z.ZodNumber>;
+            outputText: z.ZodString;
+            reachedTokenLimit: z.ZodBoolean;
+            forwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>>;
+        role: z.ZodLiteral<"frozen">;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        baseline: z.ZodObject<{
+            candidateHash: z.ZodString;
+            rows: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                inputHash: z.ZodString;
+                outputIds: z.ZodArray<z.ZodNumber>;
+                outputText: z.ZodString;
+                reachedTokenLimit: z.ZodBoolean;
+                forwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    usage: z.ZodObject<{
+        commands: z.ZodNumber;
+        candidates: z.ZodNumber;
+        arithmeticWork: z.ZodNumber;
+        forwardTokenWork: z.ZodNumber;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type WeightSpaceCommandResult = z.infer<typeof WeightSpaceCommandResultSchema>;
+export declare function parseAndVerifyWeightSpaceCommandResult(raw: unknown, command: WeightSpaceCommand): Promise<{
+    schemaVersion: "openpond.weightSpaceCommandResult.v1";
+    sessionId: string;
+    operationId: string;
+    requestHash: string;
+    revision: number;
+    parentCandidateHash: string;
+    candidateHash: string;
+    changedColumns: {
+        layer: number;
+        columns: number[];
+    }[];
+    status: "rejected" | "succeeded";
+    code: string | null;
+    catalog: {
+        items: {
+            name: string;
+            shape: number[];
+            dtype: "BF16";
+            editable: boolean;
+        }[];
+        nextOffset: number | null;
+    } | null;
+    tensors: Record<string, {
+        shape: number[];
+        minimum: number;
+        maximum: number;
+        mean: number;
+        norm: number;
+        values: number[];
+        truncated: boolean;
+    }>;
+    evaluation: {
+        panelId: string;
+        role: "development" | "preservation";
+        candidateHash: string;
+        sampling: "greedy_v1";
+        seed: number;
+        rows: {
+            id: string;
+            inputHash: string;
+            outputIds: number[];
+            outputText: string;
+            reachedTokenLimit: boolean;
+            forwardTokenWork: number;
+        }[];
+    } | null;
+    finalEvaluation?: {
+        panelId: string;
+        candidateHash: string;
+        sampling: "greedy_v1";
+        seed: number;
+        rows: {
+            id: string;
+            inputHash: string;
+            outputIds: number[];
+            outputText: string;
+            reachedTokenLimit: boolean;
+            forwardTokenWork: number;
+        }[];
+        role: "frozen";
+        source: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        baseline: {
+            candidateHash: string;
+            rows: {
+                id: string;
+                inputHash: string;
+                outputIds: number[];
+                outputText: string;
+                reachedTokenLimit: boolean;
+                forwardTokenWork: number;
+            }[];
+        };
+    } | null | undefined;
+    usage: {
+        commands: number;
+        candidates: number;
+        arithmeticWork: number;
+        forwardTokenWork: number;
+    };
+    contentHash: string;
+}>;
+export declare function weightSpaceBaseCandidateHash(request: WeightSpaceRequest): Promise<string>;
+export declare function parseAndVerifyWeightSpaceRequest(raw: unknown): Promise<{
+    schemaVersion: "openpond.weightSpaceRequest.v1";
+    model: {
+        schemaVersion: "openpond.neuronSteeringModel.v1";
+        modelId: string;
+        revision: string;
+        configHash: string;
+        weightsHash: string;
+        tokenizerHash: string;
+        weightIdentity: "torch_state_dict_sha256_v1";
+        architecture: "dense_decoder";
+        dtype: "bfloat16" | "float16" | "float32";
+        quantization: "none";
+        adapter: null;
+        hiddenSize: number;
+        intermediateSizes: number[];
+    };
+    teacher: {
+        controller: "local_agent";
+        providerId: string;
+        modelId: string;
+        sessionId: string;
+    };
+    objective: string;
+    panels: {
+        id: string;
+        source: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        role: "development" | "preservation";
+        prompts: {
+            id: string;
+            text: string;
+            system?: string | undefined;
+        }[];
+    }[];
+    frozenEvaluation: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    } | null;
+    generation: {
+        maxOutputTokens: number;
+        seed: number;
+        sampling: "greedy_v1";
+    };
+    limits: {
+        maximumDurationSeconds: number;
+        maximumIdleSeconds: number;
+        maximumCommands: number;
+        maximumCandidates: number;
+        maximumPatchColumns: number;
+        maximumTensorElements: number;
+        maximumReturnedValues: number;
+        maximumArithmeticWork: number;
+        maximumForwardTokenWork: number;
+        maximumCheckpointBytes: number;
+    };
+}>;
+//# sourceMappingURL=weight-space-programming.d.ts.map