npm - openpond-sdk - Versions diffs - 0.12.13 → 0.12.15 - Mend

openpond-sdk 0.12.13 → 0.12.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (301) hide show

package/dist/types/packages/sdk/src/weight-model-versions.d.ts ADDED Viewed

@@ -0,0 +1,4578 @@
+import { z } from "zod";
+export declare const AlphaEditModelVersionContentSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    modelProjectId: z.ZodString;
+    portableProjectId: z.ZodString;
+    baseModel: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodNullable<z.ZodString>;
+        tokenizerRevision: z.ZodNullable<z.ZodString>;
+        chatTemplateHash: z.ZodNullable<z.ZodString>;
+        modelAssetId: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            builtin: "builtin";
+            local: "local";
+            managed: "managed";
+        }>;
+    }, z.core.$strict>;
+    source: z.ZodObject<{
+        executionId: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        resultHash: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    schemaVersion: z.ZodLiteral<"openpond.alphaEditModelVersion.v1">;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.alphaEditTrainingRequest.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>;
+        data: z.ZodObject<{
+            edits: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+            }, z.core.$strict>;
+            preservation: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        config: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.alphaEditConfig.v1">;
+            implementation: z.ZodLiteral<"openpond_qwen_alphaedit_v1">;
+            sourceRevision: z.ZodLiteral<"b84624f44dfe8fc6cd9e41df916c44124a0c46dc">;
+            rewriteModule: z.ZodLiteral<"mlp.down_proj.weight">;
+            factToken: z.ZodLiteral<"subject_last">;
+            layers: z.ZodArray<z.ZodNumber>;
+            lossLayer: z.ZodNumber;
+            contextTemplateGroups: z.ZodArray<z.ZodArray<z.ZodString>>;
+            nullspaceThreshold: z.ZodNumber;
+            l2: z.ZodNumber;
+            covariance: z.ZodLiteral<"non_padding_uncentered_second_moment_fp32_v1">;
+            projector: z.ZodLiteral<"covariance_svd_below_absolute_threshold_v1">;
+            sequentialState: z.ZodLiteral<"post_edit_group_mean_keys_outer_product_sum_v1">;
+            targetTokenization: z.ZodLiteral<"leading_space_no_special_tokens_v1">;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            maxSteps: z.ZodNumber;
+            learningRate: z.ZodNumber;
+            klFactor: z.ZodNumber;
+            latentWeightDecay: z.ZodNumber;
+            clampNormFactor: z.ZodNumber;
+            maxSequenceLength: z.ZodNumber;
+            maxDurationSeconds: z.ZodNumber;
+            maxForwardTokenWork: z.ZodNumber;
+            maxCheckpointBytes: z.ZodNumber;
+            seed: z.ZodNumber;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    artifact: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.alphaEditArtifact.v1">;
+            method: z.ZodLiteral<"alphaedit">;
+            config: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.alphaEditConfig.v1">;
+                implementation: z.ZodLiteral<"openpond_qwen_alphaedit_v1">;
+                sourceRevision: z.ZodLiteral<"b84624f44dfe8fc6cd9e41df916c44124a0c46dc">;
+                rewriteModule: z.ZodLiteral<"mlp.down_proj.weight">;
+                factToken: z.ZodLiteral<"subject_last">;
+                layers: z.ZodArray<z.ZodNumber>;
+                lossLayer: z.ZodNumber;
+                contextTemplateGroups: z.ZodArray<z.ZodArray<z.ZodString>>;
+                nullspaceThreshold: z.ZodNumber;
+                l2: z.ZodNumber;
+                covariance: z.ZodLiteral<"non_padding_uncentered_second_moment_fp32_v1">;
+                projector: z.ZodLiteral<"covariance_svd_below_absolute_threshold_v1">;
+                sequentialState: z.ZodLiteral<"post_edit_group_mean_keys_outer_product_sum_v1">;
+                targetTokenization: z.ZodLiteral<"leading_space_no_special_tokens_v1">;
+            }, z.core.$strict>;
+            pins: z.ZodObject<{
+                baseModel: 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>;
+                configHash: z.ZodString;
+                recipeHash: z.ZodString;
+                dataHash: z.ZodString;
+                data: z.ZodObject<{
+                    edits: z.ZodObject<{
+                        batch: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        examplesSha256: z.ZodString;
+                    }, z.core.$strict>;
+                    preservation: z.ZodObject<{
+                        batch: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        examplesSha256: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>;
+                runtimeHash: z.ZodString;
+                parentArtifactHash: z.ZodNullable<z.ZodString>;
+                preservationModelHash: z.ZodString;
+            }, z.core.$strict>;
+            representation: z.ZodLiteral<"exact_replacement_bf16_down_proj_matrices_v1">;
+            payloads: z.ZodObject<{
+                patch: z.ZodObject<{
+                    sha256: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    tensors: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        shape: z.ZodArray<z.ZodNumber>;
+                        dtype: z.ZodEnum<{
+                            BF16: "BF16";
+                            F32: "F32";
+                        }>;
+                    }, z.core.$strict>>;
+                    path: z.ZodLiteral<"patch.safetensors">;
+                }, z.core.$strict>;
+                state: z.ZodArray<z.ZodObject<{
+                    sha256: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    tensors: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        shape: z.ZodArray<z.ZodNumber>;
+                        dtype: z.ZodEnum<{
+                            BF16: "BF16";
+                            F32: "F32";
+                        }>;
+                    }, z.core.$strict>>;
+                    path: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodUnion<readonly [z.ZodEnum<{
+                "manifest.json": "manifest.json";
+                "patch.safetensors": "patch.safetensors";
+            }>, z.ZodString]>;
+            artifactId: z.ZodString;
+            sha256: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const AlphaEditModelVersionSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    modelProjectId: z.ZodString;
+    portableProjectId: z.ZodString;
+    baseModel: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodNullable<z.ZodString>;
+        tokenizerRevision: z.ZodNullable<z.ZodString>;
+        chatTemplateHash: z.ZodNullable<z.ZodString>;
+        modelAssetId: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            builtin: "builtin";
+            local: "local";
+            managed: "managed";
+        }>;
+    }, z.core.$strict>;
+    source: z.ZodObject<{
+        executionId: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        resultHash: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    schemaVersion: z.ZodLiteral<"openpond.alphaEditModelVersion.v1">;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.alphaEditTrainingRequest.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>;
+        data: z.ZodObject<{
+            edits: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+            }, z.core.$strict>;
+            preservation: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        config: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.alphaEditConfig.v1">;
+            implementation: z.ZodLiteral<"openpond_qwen_alphaedit_v1">;
+            sourceRevision: z.ZodLiteral<"b84624f44dfe8fc6cd9e41df916c44124a0c46dc">;
+            rewriteModule: z.ZodLiteral<"mlp.down_proj.weight">;
+            factToken: z.ZodLiteral<"subject_last">;
+            layers: z.ZodArray<z.ZodNumber>;
+            lossLayer: z.ZodNumber;
+            contextTemplateGroups: z.ZodArray<z.ZodArray<z.ZodString>>;
+            nullspaceThreshold: z.ZodNumber;
+            l2: z.ZodNumber;
+            covariance: z.ZodLiteral<"non_padding_uncentered_second_moment_fp32_v1">;
+            projector: z.ZodLiteral<"covariance_svd_below_absolute_threshold_v1">;
+            sequentialState: z.ZodLiteral<"post_edit_group_mean_keys_outer_product_sum_v1">;
+            targetTokenization: z.ZodLiteral<"leading_space_no_special_tokens_v1">;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            maxSteps: z.ZodNumber;
+            learningRate: z.ZodNumber;
+            klFactor: z.ZodNumber;
+            latentWeightDecay: z.ZodNumber;
+            clampNormFactor: z.ZodNumber;
+            maxSequenceLength: z.ZodNumber;
+            maxDurationSeconds: z.ZodNumber;
+            maxForwardTokenWork: z.ZodNumber;
+            maxCheckpointBytes: z.ZodNumber;
+            seed: z.ZodNumber;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    artifact: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.alphaEditArtifact.v1">;
+            method: z.ZodLiteral<"alphaedit">;
+            config: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.alphaEditConfig.v1">;
+                implementation: z.ZodLiteral<"openpond_qwen_alphaedit_v1">;
+                sourceRevision: z.ZodLiteral<"b84624f44dfe8fc6cd9e41df916c44124a0c46dc">;
+                rewriteModule: z.ZodLiteral<"mlp.down_proj.weight">;
+                factToken: z.ZodLiteral<"subject_last">;
+                layers: z.ZodArray<z.ZodNumber>;
+                lossLayer: z.ZodNumber;
+                contextTemplateGroups: z.ZodArray<z.ZodArray<z.ZodString>>;
+                nullspaceThreshold: z.ZodNumber;
+                l2: z.ZodNumber;
+                covariance: z.ZodLiteral<"non_padding_uncentered_second_moment_fp32_v1">;
+                projector: z.ZodLiteral<"covariance_svd_below_absolute_threshold_v1">;
+                sequentialState: z.ZodLiteral<"post_edit_group_mean_keys_outer_product_sum_v1">;
+                targetTokenization: z.ZodLiteral<"leading_space_no_special_tokens_v1">;
+            }, z.core.$strict>;
+            pins: z.ZodObject<{
+                baseModel: 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>;
+                configHash: z.ZodString;
+                recipeHash: z.ZodString;
+                dataHash: z.ZodString;
+                data: z.ZodObject<{
+                    edits: z.ZodObject<{
+                        batch: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        examplesSha256: z.ZodString;
+                    }, z.core.$strict>;
+                    preservation: z.ZodObject<{
+                        batch: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        examplesSha256: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>;
+                runtimeHash: z.ZodString;
+                parentArtifactHash: z.ZodNullable<z.ZodString>;
+                preservationModelHash: z.ZodString;
+            }, z.core.$strict>;
+            representation: z.ZodLiteral<"exact_replacement_bf16_down_proj_matrices_v1">;
+            payloads: z.ZodObject<{
+                patch: z.ZodObject<{
+                    sha256: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    tensors: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        shape: z.ZodArray<z.ZodNumber>;
+                        dtype: z.ZodEnum<{
+                            BF16: "BF16";
+                            F32: "F32";
+                        }>;
+                    }, z.core.$strict>>;
+                    path: z.ZodLiteral<"patch.safetensors">;
+                }, z.core.$strict>;
+                state: z.ZodArray<z.ZodObject<{
+                    sha256: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    tensors: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        shape: z.ZodArray<z.ZodNumber>;
+                        dtype: z.ZodEnum<{
+                            BF16: "BF16";
+                            F32: "F32";
+                        }>;
+                    }, z.core.$strict>>;
+                    path: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodUnion<readonly [z.ZodEnum<{
+                "manifest.json": "manifest.json";
+                "patch.safetensors": "patch.safetensors";
+            }>, z.ZodString]>;
+            artifactId: z.ZodString;
+            sha256: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type AlphaEditModelVersion = z.infer<typeof AlphaEditModelVersionSchema>;
+export declare const NeuronTrainingModelVersionContentSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    modelProjectId: z.ZodString;
+    portableProjectId: z.ZodString;
+    baseModel: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodNullable<z.ZodString>;
+        tokenizerRevision: z.ZodNullable<z.ZodString>;
+        chatTemplateHash: z.ZodNullable<z.ZodString>;
+        modelAssetId: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            builtin: "builtin";
+            local: "local";
+            managed: "managed";
+        }>;
+    }, z.core.$strict>;
+    source: z.ZodObject<{
+        executionId: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        resultHash: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingModelVersion.v1">;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.selectiveNeuronTrainingRequest.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>;
+        data: z.ZodObject<{
+            target: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>;
+            background: z.ZodArray<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+                domain: z.ZodString;
+            }, z.core.$strict>>;
+            preservation: z.ZodNullable<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        selection: z.ZodObject<{
+            count: z.ZodNumber;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodNumber;
+            gradientExamples: z.ZodNumber;
+            explicitCoordinates: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                neuron: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodNumber;
+            maxSteps: z.ZodNumber;
+            gradientAccumulationSteps: z.ZodNumber;
+            maxSequenceLength: z.ZodNumber;
+            preservationWeight: z.ZodNumber;
+            preservationExamplesPerStep: z.ZodNumber;
+            seed: z.ZodNumber;
+            maxDurationSeconds: z.ZodNumber;
+            maxCheckpointBytes: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+    }, z.core.$strict>;
+    artifact: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronTrainingArtifact.v1">;
+            method: z.ZodLiteral<"selective_neuron_training">;
+            algorithm: z.ZodObject<{
+                implementation: z.ZodLiteral<"openpond_qwen3_selective_columns_v1">;
+                upstream: z.ZodLiteral<"changjonathanc/neuron-tuning">;
+                revision: z.ZodLiteral<"8a55f3159f735eb0823d7a894f67f632bf568bb3">;
+                license: z.ZodLiteral<"Apache-2.0">;
+                hook: z.ZodLiteral<"mlp.down_proj">;
+                operation: z.ZodLiteral<"output_plus_selected_input_times_delta_v1">;
+                parameterization: z.ZodLiteral<"column_gain_rms_direction_v1">;
+                activityQuantile: z.ZodLiteral<0.9>;
+                backgroundFloor: z.ZodLiteral<0.000001>;
+                gradientSubsetSeed: z.ZodLiteral<0>;
+                optimizer: z.ZodLiteral<"Adam">;
+                betas: z.ZodTuple<[z.ZodLiteral<0.9>, z.ZodLiteral<0.999>], null>;
+                epsilon: z.ZodLiteral<1e-8>;
+                weightDecay: z.ZodLiteral<0>;
+                gradientClipNorm: z.ZodLiteral<1>;
+                batchSize: z.ZodLiteral<1>;
+                parameterDtype: z.ZodLiteral<"float32">;
+                resume: z.ZodLiteral<"unsupported">;
+            }, z.core.$strict>;
+            pins: z.ZodObject<{
+                baseModel: 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>;
+                inputHash: z.ZodString;
+                data: z.ZodObject<{
+                    target: z.ZodObject<{
+                        batch: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        examplesSha256: z.ZodString;
+                        encodingHash: z.ZodString;
+                    }, z.core.$strict>;
+                    background: z.ZodArray<z.ZodObject<{
+                        batch: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        examplesSha256: z.ZodString;
+                        encodingHash: z.ZodString;
+                        domain: z.ZodString;
+                    }, z.core.$strict>>;
+                    preservation: z.ZodNullable<z.ZodObject<{
+                        batch: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        examplesSha256: z.ZodString;
+                        encodingHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                dataHash: z.ZodString;
+                selectionConfigHash: z.ZodString;
+                trainingConfigHash: z.ZodString;
+                runtimeHash: z.ZodString;
+                parentArtifactHash: z.ZodNull;
+            }, z.core.$strict>;
+            selection: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+                modelHash: z.ZodString;
+                dataHash: z.ZodString;
+                selectionConfigHash: z.ZodString;
+                preparedRowsHash: z.ZodString;
+                source: z.ZodEnum<{
+                    automatic: "automatic";
+                    explicit: "explicit";
+                }>;
+                targetExampleIds: z.ZodArray<z.ZodString>;
+                eligibleCount: z.ZodNumber;
+                entries: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    neuron: z.ZodNumber;
+                    targetMeanAbsolute: z.ZodNumber;
+                    backgroundMeanAbsolute: z.ZodNumber;
+                    backgroundTargetRatio: z.ZodNumber;
+                    gradientNorm: z.ZodNumber;
+                    score: z.ZodNumber;
+                    targetActivityThreshold: z.ZodNumber;
+                    backgroundByDomain: z.ZodArray<z.ZodObject<{
+                        domainIndex: z.ZodNumber;
+                        meanAbsolute: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            payload: z.ZodObject<{
+                path: z.ZodLiteral<"patch.safetensors">;
+                sha256: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                tensors: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    dtype: z.ZodEnum<{
+                        F32: "F32";
+                        I64: "I64";
+                    }>;
+                    shape: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodEnum<{
+                "manifest.json": "manifest.json";
+                "patch.safetensors": "patch.safetensors";
+            }>;
+            artifactId: z.ZodString;
+            sha256: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const NeuronTrainingModelVersionSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    ownerUserId: z.ZodString;
+    modelProjectId: z.ZodString;
+    portableProjectId: z.ZodString;
+    baseModel: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodNullable<z.ZodString>;
+        tokenizerRevision: z.ZodNullable<z.ZodString>;
+        chatTemplateHash: z.ZodNullable<z.ZodString>;
+        modelAssetId: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            builtin: "builtin";
+            local: "local";
+            managed: "managed";
+        }>;
+    }, z.core.$strict>;
+    source: z.ZodObject<{
+        executionId: z.ZodString;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        resultHash: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingModelVersion.v1">;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.selectiveNeuronTrainingRequest.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>;
+        data: z.ZodObject<{
+            target: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>;
+            background: z.ZodArray<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+                domain: z.ZodString;
+            }, z.core.$strict>>;
+            preservation: z.ZodNullable<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        selection: z.ZodObject<{
+            count: z.ZodNumber;
+            span: z.ZodEnum<{
+                prompt: "prompt";
+                reply_prediction: "reply_prediction";
+                reply_start: "reply_start";
+            }>;
+            backgroundStatistic: z.ZodEnum<{
+                max_domains: "max_domains";
+                mean_domains: "mean_domains";
+            }>;
+            maximumBackgroundTargetRatio: z.ZodNumber;
+            gradientExamples: z.ZodNumber;
+            explicitCoordinates: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                neuron: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        training: z.ZodObject<{
+            learningRate: z.ZodNumber;
+            maxSteps: z.ZodNumber;
+            gradientAccumulationSteps: z.ZodNumber;
+            maxSequenceLength: z.ZodNumber;
+            preservationWeight: z.ZodNumber;
+            preservationExamplesPerStep: z.ZodNumber;
+            seed: z.ZodNumber;
+            maxDurationSeconds: z.ZodNumber;
+            maxCheckpointBytes: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+        }, z.core.$strict>;
+        parentArtifact: z.ZodNull;
+    }, z.core.$strict>;
+    artifact: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronTrainingArtifact.v1">;
+            method: z.ZodLiteral<"selective_neuron_training">;
+            algorithm: z.ZodObject<{
+                implementation: z.ZodLiteral<"openpond_qwen3_selective_columns_v1">;
+                upstream: z.ZodLiteral<"changjonathanc/neuron-tuning">;
+                revision: z.ZodLiteral<"8a55f3159f735eb0823d7a894f67f632bf568bb3">;
+                license: z.ZodLiteral<"Apache-2.0">;
+                hook: z.ZodLiteral<"mlp.down_proj">;
+                operation: z.ZodLiteral<"output_plus_selected_input_times_delta_v1">;
+                parameterization: z.ZodLiteral<"column_gain_rms_direction_v1">;
+                activityQuantile: z.ZodLiteral<0.9>;
+                backgroundFloor: z.ZodLiteral<0.000001>;
+                gradientSubsetSeed: z.ZodLiteral<0>;
+                optimizer: z.ZodLiteral<"Adam">;
+                betas: z.ZodTuple<[z.ZodLiteral<0.9>, z.ZodLiteral<0.999>], null>;
+                epsilon: z.ZodLiteral<1e-8>;
+                weightDecay: z.ZodLiteral<0>;
+                gradientClipNorm: z.ZodLiteral<1>;
+                batchSize: z.ZodLiteral<1>;
+                parameterDtype: z.ZodLiteral<"float32">;
+                resume: z.ZodLiteral<"unsupported">;
+            }, z.core.$strict>;
+            pins: z.ZodObject<{
+                baseModel: 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>;
+                inputHash: z.ZodString;
+                data: z.ZodObject<{
+                    target: z.ZodObject<{
+                        batch: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        examplesSha256: z.ZodString;
+                        encodingHash: z.ZodString;
+                    }, z.core.$strict>;
+                    background: z.ZodArray<z.ZodObject<{
+                        batch: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        examplesSha256: z.ZodString;
+                        encodingHash: z.ZodString;
+                        domain: z.ZodString;
+                    }, z.core.$strict>>;
+                    preservation: z.ZodNullable<z.ZodObject<{
+                        batch: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        examplesSha256: z.ZodString;
+                        encodingHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                dataHash: z.ZodString;
+                selectionConfigHash: z.ZodString;
+                trainingConfigHash: z.ZodString;
+                runtimeHash: z.ZodString;
+                parentArtifactHash: z.ZodNull;
+            }, z.core.$strict>;
+            selection: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+                modelHash: z.ZodString;
+                dataHash: z.ZodString;
+                selectionConfigHash: z.ZodString;
+                preparedRowsHash: z.ZodString;
+                source: z.ZodEnum<{
+                    automatic: "automatic";
+                    explicit: "explicit";
+                }>;
+                targetExampleIds: z.ZodArray<z.ZodString>;
+                eligibleCount: z.ZodNumber;
+                entries: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    neuron: z.ZodNumber;
+                    targetMeanAbsolute: z.ZodNumber;
+                    backgroundMeanAbsolute: z.ZodNumber;
+                    backgroundTargetRatio: z.ZodNumber;
+                    gradientNorm: z.ZodNumber;
+                    score: z.ZodNumber;
+                    targetActivityThreshold: z.ZodNumber;
+                    backgroundByDomain: z.ZodArray<z.ZodObject<{
+                        domainIndex: z.ZodNumber;
+                        meanAbsolute: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            payload: z.ZodObject<{
+                path: z.ZodLiteral<"patch.safetensors">;
+                sha256: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                tensors: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    dtype: z.ZodEnum<{
+                        F32: "F32";
+                        I64: "I64";
+                    }>;
+                    shape: z.ZodArray<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodEnum<{
+                "manifest.json": "manifest.json";
+                "patch.safetensors": "patch.safetensors";
+            }>;
+            artifactId: z.ZodString;
+            sha256: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronTrainingModelVersion = z.infer<typeof NeuronTrainingModelVersionSchema>;
+type Scope = {
+    teamId?: string;
+    modelProjectId?: string;
+    ownerUserId?: string;
+};
+/** Verifies retained metadata; actual blob possession/authorization belongs to
+ * the artifact custodian on every publication and serving admission. */
+export declare function parseAndVerifyAlphaEditModelVersion(raw: unknown, expected?: Scope): Promise<{
+    teamId: string;
+    ownerUserId: string;
+    modelProjectId: string;
+    portableProjectId: string;
+    baseModel: {
+        schemaVersion: "openpond.baseModelPreference.v1";
+        modelId: string;
+        revision: string | null;
+        tokenizerRevision: string | null;
+        chatTemplateHash: string | null;
+        modelAssetId: string | null;
+        source: "builtin" | "local" | "managed";
+    };
+    source: {
+        executionId: string;
+        inputHash: string;
+        runtimeHash: string;
+        resultHash: string;
+    };
+    createdAt: string;
+    schemaVersion: "openpond.alphaEditModelVersion.v1";
+    request: {
+        schemaVersion: "openpond.alphaEditTrainingRequest.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[];
+        };
+        data: {
+            edits: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+            };
+            preservation: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+            };
+        };
+        config: {
+            schemaVersion: "openpond.alphaEditConfig.v1";
+            implementation: "openpond_qwen_alphaedit_v1";
+            sourceRevision: "b84624f44dfe8fc6cd9e41df916c44124a0c46dc";
+            rewriteModule: "mlp.down_proj.weight";
+            factToken: "subject_last";
+            layers: number[];
+            lossLayer: number;
+            contextTemplateGroups: string[][];
+            nullspaceThreshold: number;
+            l2: number;
+            covariance: "non_padding_uncentered_second_moment_fp32_v1";
+            projector: "covariance_svd_below_absolute_threshold_v1";
+            sequentialState: "post_edit_group_mean_keys_outer_product_sum_v1";
+            targetTokenization: "leading_space_no_special_tokens_v1";
+        };
+        training: {
+            maxSteps: number;
+            learningRate: number;
+            klFactor: number;
+            latentWeightDecay: number;
+            clampNormFactor: number;
+            maxSequenceLength: number;
+            maxDurationSeconds: number;
+            maxForwardTokenWork: number;
+            maxCheckpointBytes: number;
+            seed: number;
+        };
+        parentArtifact: {
+            id: string;
+            contentHash: string;
+        } | null;
+    };
+    artifact: {
+        id: string;
+        contentHash: string;
+        manifest: {
+            schemaVersion: "openpond.alphaEditArtifact.v1";
+            method: "alphaedit";
+            config: {
+                schemaVersion: "openpond.alphaEditConfig.v1";
+                implementation: "openpond_qwen_alphaedit_v1";
+                sourceRevision: "b84624f44dfe8fc6cd9e41df916c44124a0c46dc";
+                rewriteModule: "mlp.down_proj.weight";
+                factToken: "subject_last";
+                layers: number[];
+                lossLayer: number;
+                contextTemplateGroups: string[][];
+                nullspaceThreshold: number;
+                l2: number;
+                covariance: "non_padding_uncentered_second_moment_fp32_v1";
+                projector: "covariance_svd_below_absolute_threshold_v1";
+                sequentialState: "post_edit_group_mean_keys_outer_product_sum_v1";
+                targetTokenization: "leading_space_no_special_tokens_v1";
+            };
+            pins: {
+                baseModel: {
+                    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[];
+                };
+                configHash: string;
+                recipeHash: string;
+                dataHash: string;
+                data: {
+                    edits: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                    };
+                    preservation: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                    };
+                };
+                runtimeHash: string;
+                parentArtifactHash: string | null;
+                preservationModelHash: string;
+            };
+            representation: "exact_replacement_bf16_down_proj_matrices_v1";
+            payloads: {
+                patch: {
+                    sha256: string;
+                    sizeBytes: number;
+                    tensors: {
+                        name: string;
+                        shape: number[];
+                        dtype: "BF16" | "F32";
+                    }[];
+                    path: "patch.safetensors";
+                };
+                state: {
+                    sha256: string;
+                    sizeBytes: number;
+                    tensors: {
+                        name: string;
+                        shape: number[];
+                        dtype: "BF16" | "F32";
+                    }[];
+                    path: string;
+                }[];
+            };
+            contentHash: string;
+        };
+        files: {
+            path: string;
+            artifactId: string;
+            sha256: string;
+            sizeBytes: number;
+        }[];
+    };
+    contentHash: string;
+}>;
+export declare function parseAndVerifyNeuronTrainingModelVersion(raw: unknown, expected?: Scope): Promise<{
+    teamId: string;
+    ownerUserId: string;
+    modelProjectId: string;
+    portableProjectId: string;
+    baseModel: {
+        schemaVersion: "openpond.baseModelPreference.v1";
+        modelId: string;
+        revision: string | null;
+        tokenizerRevision: string | null;
+        chatTemplateHash: string | null;
+        modelAssetId: string | null;
+        source: "builtin" | "local" | "managed";
+    };
+    source: {
+        executionId: string;
+        inputHash: string;
+        runtimeHash: string;
+        resultHash: string;
+    };
+    createdAt: string;
+    schemaVersion: "openpond.neuronTrainingModelVersion.v1";
+    request: {
+        schemaVersion: "openpond.selectiveNeuronTrainingRequest.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[];
+        };
+        data: {
+            target: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            };
+            background: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+                domain: string;
+            }[];
+            preservation: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            } | null;
+        };
+        selection: {
+            count: number;
+            span: "prompt" | "reply_prediction" | "reply_start";
+            backgroundStatistic: "max_domains" | "mean_domains";
+            maximumBackgroundTargetRatio: number;
+            gradientExamples: number;
+            explicitCoordinates: {
+                layer: number;
+                neuron: number;
+            }[] | null;
+        };
+        training: {
+            learningRate: number;
+            maxSteps: number;
+            gradientAccumulationSteps: number;
+            maxSequenceLength: number;
+            preservationWeight: number;
+            preservationExamplesPerStep: number;
+            seed: number;
+            maxDurationSeconds: number;
+            maxCheckpointBytes: number;
+            maximumForwardTokenWork: number;
+        };
+        parentArtifact: null;
+    };
+    artifact: {
+        id: string;
+        contentHash: string;
+        manifest: {
+            schemaVersion: "openpond.neuronTrainingArtifact.v1";
+            method: "selective_neuron_training";
+            algorithm: {
+                implementation: "openpond_qwen3_selective_columns_v1";
+                upstream: "changjonathanc/neuron-tuning";
+                revision: "8a55f3159f735eb0823d7a894f67f632bf568bb3";
+                license: "Apache-2.0";
+                hook: "mlp.down_proj";
+                operation: "output_plus_selected_input_times_delta_v1";
+                parameterization: "column_gain_rms_direction_v1";
+                activityQuantile: 0.9;
+                backgroundFloor: 0.000001;
+                gradientSubsetSeed: 0;
+                optimizer: "Adam";
+                betas: [0.9, 0.999];
+                epsilon: 1e-8;
+                weightDecay: 0;
+                gradientClipNorm: 1;
+                batchSize: 1;
+                parameterDtype: "float32";
+                resume: "unsupported";
+            };
+            pins: {
+                baseModel: {
+                    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[];
+                };
+                inputHash: string;
+                data: {
+                    target: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                        encodingHash: string;
+                    };
+                    background: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                        encodingHash: string;
+                        domain: string;
+                    }[];
+                    preservation: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                        encodingHash: string;
+                    } | null;
+                };
+                dataHash: string;
+                selectionConfigHash: string;
+                trainingConfigHash: string;
+                runtimeHash: string;
+                parentArtifactHash: null;
+            };
+            selection: {
+                schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
+                modelHash: string;
+                dataHash: string;
+                selectionConfigHash: string;
+                preparedRowsHash: string;
+                source: "automatic" | "explicit";
+                targetExampleIds: string[];
+                eligibleCount: number;
+                entries: {
+                    layer: number;
+                    neuron: number;
+                    targetMeanAbsolute: number;
+                    backgroundMeanAbsolute: number;
+                    backgroundTargetRatio: number;
+                    gradientNorm: number;
+                    score: number;
+                    targetActivityThreshold: number;
+                    backgroundByDomain: {
+                        domainIndex: number;
+                        meanAbsolute: number;
+                    }[];
+                }[];
+                contentHash: string;
+            };
+            payload: {
+                path: "patch.safetensors";
+                sha256: string;
+                sizeBytes: number;
+                tensors: {
+                    name: string;
+                    dtype: "F32" | "I64";
+                    shape: number[];
+                }[];
+            };
+            contentHash: string;
+        };
+        files: {
+            path: "manifest.json" | "patch.safetensors";
+            artifactId: string;
+            sha256: string;
+            sizeBytes: number;
+        }[];
+    };
+    contentHash: string;
+}>;
+export declare function verifySavedAlphaEditExperimentSource(sourceInput: unknown, raw: unknown, expected?: Scope): Promise<{
+    teamId: string;
+    ownerUserId: string;
+    modelProjectId: string;
+    portableProjectId: string;
+    baseModel: {
+        schemaVersion: "openpond.baseModelPreference.v1";
+        modelId: string;
+        revision: string | null;
+        tokenizerRevision: string | null;
+        chatTemplateHash: string | null;
+        modelAssetId: string | null;
+        source: "builtin" | "local" | "managed";
+    };
+    source: {
+        executionId: string;
+        inputHash: string;
+        runtimeHash: string;
+        resultHash: string;
+    };
+    createdAt: string;
+    schemaVersion: "openpond.alphaEditModelVersion.v1";
+    request: {
+        schemaVersion: "openpond.alphaEditTrainingRequest.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[];
+        };
+        data: {
+            edits: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+            };
+            preservation: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+            };
+        };
+        config: {
+            schemaVersion: "openpond.alphaEditConfig.v1";
+            implementation: "openpond_qwen_alphaedit_v1";
+            sourceRevision: "b84624f44dfe8fc6cd9e41df916c44124a0c46dc";
+            rewriteModule: "mlp.down_proj.weight";
+            factToken: "subject_last";
+            layers: number[];
+            lossLayer: number;
+            contextTemplateGroups: string[][];
+            nullspaceThreshold: number;
+            l2: number;
+            covariance: "non_padding_uncentered_second_moment_fp32_v1";
+            projector: "covariance_svd_below_absolute_threshold_v1";
+            sequentialState: "post_edit_group_mean_keys_outer_product_sum_v1";
+            targetTokenization: "leading_space_no_special_tokens_v1";
+        };
+        training: {
+            maxSteps: number;
+            learningRate: number;
+            klFactor: number;
+            latentWeightDecay: number;
+            clampNormFactor: number;
+            maxSequenceLength: number;
+            maxDurationSeconds: number;
+            maxForwardTokenWork: number;
+            maxCheckpointBytes: number;
+            seed: number;
+        };
+        parentArtifact: {
+            id: string;
+            contentHash: string;
+        } | null;
+    };
+    artifact: {
+        id: string;
+        contentHash: string;
+        manifest: {
+            schemaVersion: "openpond.alphaEditArtifact.v1";
+            method: "alphaedit";
+            config: {
+                schemaVersion: "openpond.alphaEditConfig.v1";
+                implementation: "openpond_qwen_alphaedit_v1";
+                sourceRevision: "b84624f44dfe8fc6cd9e41df916c44124a0c46dc";
+                rewriteModule: "mlp.down_proj.weight";
+                factToken: "subject_last";
+                layers: number[];
+                lossLayer: number;
+                contextTemplateGroups: string[][];
+                nullspaceThreshold: number;
+                l2: number;
+                covariance: "non_padding_uncentered_second_moment_fp32_v1";
+                projector: "covariance_svd_below_absolute_threshold_v1";
+                sequentialState: "post_edit_group_mean_keys_outer_product_sum_v1";
+                targetTokenization: "leading_space_no_special_tokens_v1";
+            };
+            pins: {
+                baseModel: {
+                    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[];
+                };
+                configHash: string;
+                recipeHash: string;
+                dataHash: string;
+                data: {
+                    edits: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                    };
+                    preservation: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                    };
+                };
+                runtimeHash: string;
+                parentArtifactHash: string | null;
+                preservationModelHash: string;
+            };
+            representation: "exact_replacement_bf16_down_proj_matrices_v1";
+            payloads: {
+                patch: {
+                    sha256: string;
+                    sizeBytes: number;
+                    tensors: {
+                        name: string;
+                        shape: number[];
+                        dtype: "BF16" | "F32";
+                    }[];
+                    path: "patch.safetensors";
+                };
+                state: {
+                    sha256: string;
+                    sizeBytes: number;
+                    tensors: {
+                        name: string;
+                        shape: number[];
+                        dtype: "BF16" | "F32";
+                    }[];
+                    path: string;
+                }[];
+            };
+            contentHash: string;
+        };
+        files: {
+            path: string;
+            artifactId: string;
+            sha256: string;
+            sizeBytes: number;
+        }[];
+    };
+    contentHash: string;
+}>;
+export declare function verifySavedNeuronTrainingExperimentSource(sourceInput: unknown, raw: unknown, expected?: Scope): Promise<{
+    teamId: string;
+    ownerUserId: string;
+    modelProjectId: string;
+    portableProjectId: string;
+    baseModel: {
+        schemaVersion: "openpond.baseModelPreference.v1";
+        modelId: string;
+        revision: string | null;
+        tokenizerRevision: string | null;
+        chatTemplateHash: string | null;
+        modelAssetId: string | null;
+        source: "builtin" | "local" | "managed";
+    };
+    source: {
+        executionId: string;
+        inputHash: string;
+        runtimeHash: string;
+        resultHash: string;
+    };
+    createdAt: string;
+    schemaVersion: "openpond.neuronTrainingModelVersion.v1";
+    request: {
+        schemaVersion: "openpond.selectiveNeuronTrainingRequest.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[];
+        };
+        data: {
+            target: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            };
+            background: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+                domain: string;
+            }[];
+            preservation: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            } | null;
+        };
+        selection: {
+            count: number;
+            span: "prompt" | "reply_prediction" | "reply_start";
+            backgroundStatistic: "max_domains" | "mean_domains";
+            maximumBackgroundTargetRatio: number;
+            gradientExamples: number;
+            explicitCoordinates: {
+                layer: number;
+                neuron: number;
+            }[] | null;
+        };
+        training: {
+            learningRate: number;
+            maxSteps: number;
+            gradientAccumulationSteps: number;
+            maxSequenceLength: number;
+            preservationWeight: number;
+            preservationExamplesPerStep: number;
+            seed: number;
+            maxDurationSeconds: number;
+            maxCheckpointBytes: number;
+            maximumForwardTokenWork: number;
+        };
+        parentArtifact: null;
+    };
+    artifact: {
+        id: string;
+        contentHash: string;
+        manifest: {
+            schemaVersion: "openpond.neuronTrainingArtifact.v1";
+            method: "selective_neuron_training";
+            algorithm: {
+                implementation: "openpond_qwen3_selective_columns_v1";
+                upstream: "changjonathanc/neuron-tuning";
+                revision: "8a55f3159f735eb0823d7a894f67f632bf568bb3";
+                license: "Apache-2.0";
+                hook: "mlp.down_proj";
+                operation: "output_plus_selected_input_times_delta_v1";
+                parameterization: "column_gain_rms_direction_v1";
+                activityQuantile: 0.9;
+                backgroundFloor: 0.000001;
+                gradientSubsetSeed: 0;
+                optimizer: "Adam";
+                betas: [0.9, 0.999];
+                epsilon: 1e-8;
+                weightDecay: 0;
+                gradientClipNorm: 1;
+                batchSize: 1;
+                parameterDtype: "float32";
+                resume: "unsupported";
+            };
+            pins: {
+                baseModel: {
+                    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[];
+                };
+                inputHash: string;
+                data: {
+                    target: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                        encodingHash: string;
+                    };
+                    background: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                        encodingHash: string;
+                        domain: string;
+                    }[];
+                    preservation: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                        encodingHash: string;
+                    } | null;
+                };
+                dataHash: string;
+                selectionConfigHash: string;
+                trainingConfigHash: string;
+                runtimeHash: string;
+                parentArtifactHash: null;
+            };
+            selection: {
+                schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
+                modelHash: string;
+                dataHash: string;
+                selectionConfigHash: string;
+                preparedRowsHash: string;
+                source: "automatic" | "explicit";
+                targetExampleIds: string[];
+                eligibleCount: number;
+                entries: {
+                    layer: number;
+                    neuron: number;
+                    targetMeanAbsolute: number;
+                    backgroundMeanAbsolute: number;
+                    backgroundTargetRatio: number;
+                    gradientNorm: number;
+                    score: number;
+                    targetActivityThreshold: number;
+                    backgroundByDomain: {
+                        domainIndex: number;
+                        meanAbsolute: number;
+                    }[];
+                }[];
+                contentHash: string;
+            };
+            payload: {
+                path: "patch.safetensors";
+                sha256: string;
+                sizeBytes: number;
+                tensors: {
+                    name: string;
+                    dtype: "F32" | "I64";
+                    shape: number[];
+                }[];
+            };
+            contentHash: string;
+        };
+        files: {
+            path: "manifest.json" | "patch.safetensors";
+            artifactId: string;
+            sha256: string;
+            sizeBytes: number;
+        }[];
+    };
+    contentHash: string;
+}>;
+export declare const AlphaEditResultSaveRequestSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    operationId: z.ZodString;
+    executionId: z.ZodString;
+    resultHash: z.ZodString;
+    artifactHash: z.ZodString;
+    name: z.ZodString;
+    modelProjectId: z.ZodNullable<z.ZodString>;
+    expectedModelRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const NeuronTrainingResultSaveRequestSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    operationId: z.ZodString;
+    executionId: z.ZodString;
+    resultHash: z.ZodString;
+    artifactHash: z.ZodString;
+    name: z.ZodString;
+    modelProjectId: z.ZodNullable<z.ZodString>;
+    expectedModelRevision: z.ZodNumber;
+}, z.core.$strict>;
+export type AlphaEditResultSaveRequest = z.infer<typeof AlphaEditResultSaveRequestSchema>;
+export type NeuronTrainingResultSaveRequest = z.infer<typeof NeuronTrainingResultSaveRequestSchema>;
+export declare const AlphaEditResultSaveReceiptContentSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    model: z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        portableProjectId: z.ZodString;
+        name: z.ZodString;
+        objective: z.ZodNullable<z.ZodString>;
+        defaultBaseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        defaultDestinationId: z.ZodNullable<z.ZodString>;
+        trainingSetup: z.ZodObject<{
+            tasksetRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            evaluationTasksetRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            profileSource: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            profileEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                tasksetRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            rewardBindingRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            tasksetRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            harnessRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            baseModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+                tokenizerRevision: z.ZodNullable<z.ZodString>;
+                chatTemplateHash: z.ZodNullable<z.ZodString>;
+                modelAssetId: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    builtin: "builtin";
+                    local: "local";
+                    managed: "managed";
+                }>;
+            }, z.core.$strict>>>;
+            method: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                dpo: "dpo";
+                grpo: "grpo";
+                opd: "opd";
+                opsd: "opsd";
+                ppo: "ppo";
+                sdft: "sdft";
+                sdpo: "sdpo";
+                sft: "sft";
+            }>>>;
+            destinationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            managedRolloutPlacement: z.ZodDefault<z.ZodEnum<{
+                local: "local";
+                remote: "remote";
+            }>>;
+            managedGpuPlacementObjective: z.ZodDefault<z.ZodEnum<{
+                balanced: "balanced";
+                economical: "economical";
+                fast: "fast";
+            }>>;
+            managedGpuSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"automatic">;
+                objective: z.ZodEnum<{
+                    balanced: "balanced";
+                    economical: "economical";
+                    fast: "fast";
+                }>;
+                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"manual">;
+                availabilityId: z.ZodString;
+                gpuType: z.ZodString;
+                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+            }, z.core.$strict>], "mode">>;
+            continuationAdapterMode: z.ZodOptional<z.ZodEnum<{
+                residual_append: "residual_append";
+                sequential_merge: "sequential_merge";
+                shared: "shared";
+            }>>;
+            managedGpuRequirement: z.ZodDefault<z.ZodEnum<{
+                any: "any";
+                h100_hbm3: "h100_hbm3";
+            }>>;
+            runPreset: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                custom: "custom";
+                small: "small";
+                small_experiment: "small_experiment";
+                standard: "standard";
+            }>>>;
+            recipe: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodString;
+                method: z.ZodEnum<{
+                    dpo: "dpo";
+                    grpo: "grpo";
+                    opd: "opd";
+                    opsd: "opsd";
+                    ppo: "ppo";
+                    sdft: "sdft";
+                    sdpo: "sdpo";
+                    sft: "sft";
+                }>;
+                parameterization: z.ZodEnum<{
+                    full: "full";
+                    lora: "lora";
+                }>;
+            }, z.core.$catchall<z.ZodUnknown>>>>;
+            preferredMaximumSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            preferredRetentionDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>;
+        sourceRevision: z.ZodNumber;
+        sourceUpdatedAt: z.ZodString;
+        revision: z.ZodNumber;
+        etag: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<"openpond.alphaEditResultSaveReceipt.v1">;
+    version: z.ZodObject<{
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        modelProjectId: z.ZodString;
+        portableProjectId: z.ZodString;
+        baseModel: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>;
+        source: z.ZodObject<{
+            executionId: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            resultHash: z.ZodString;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+        schemaVersion: z.ZodLiteral<"openpond.alphaEditModelVersion.v1">;
+        request: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.alphaEditTrainingRequest.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>;
+            data: z.ZodObject<{
+                edits: z.ZodObject<{
+                    batch: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    examplesSha256: z.ZodString;
+                }, z.core.$strict>;
+                preservation: z.ZodObject<{
+                    batch: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    examplesSha256: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            config: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.alphaEditConfig.v1">;
+                implementation: z.ZodLiteral<"openpond_qwen_alphaedit_v1">;
+                sourceRevision: z.ZodLiteral<"b84624f44dfe8fc6cd9e41df916c44124a0c46dc">;
+                rewriteModule: z.ZodLiteral<"mlp.down_proj.weight">;
+                factToken: z.ZodLiteral<"subject_last">;
+                layers: z.ZodArray<z.ZodNumber>;
+                lossLayer: z.ZodNumber;
+                contextTemplateGroups: z.ZodArray<z.ZodArray<z.ZodString>>;
+                nullspaceThreshold: z.ZodNumber;
+                l2: z.ZodNumber;
+                covariance: z.ZodLiteral<"non_padding_uncentered_second_moment_fp32_v1">;
+                projector: z.ZodLiteral<"covariance_svd_below_absolute_threshold_v1">;
+                sequentialState: z.ZodLiteral<"post_edit_group_mean_keys_outer_product_sum_v1">;
+                targetTokenization: z.ZodLiteral<"leading_space_no_special_tokens_v1">;
+            }, z.core.$strict>;
+            training: z.ZodObject<{
+                maxSteps: z.ZodNumber;
+                learningRate: z.ZodNumber;
+                klFactor: z.ZodNumber;
+                latentWeightDecay: z.ZodNumber;
+                clampNormFactor: z.ZodNumber;
+                maxSequenceLength: z.ZodNumber;
+                maxDurationSeconds: z.ZodNumber;
+                maxForwardTokenWork: z.ZodNumber;
+                maxCheckpointBytes: z.ZodNumber;
+                seed: z.ZodNumber;
+            }, z.core.$strict>;
+            parentArtifact: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        artifact: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            manifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.alphaEditArtifact.v1">;
+                method: z.ZodLiteral<"alphaedit">;
+                config: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.alphaEditConfig.v1">;
+                    implementation: z.ZodLiteral<"openpond_qwen_alphaedit_v1">;
+                    sourceRevision: z.ZodLiteral<"b84624f44dfe8fc6cd9e41df916c44124a0c46dc">;
+                    rewriteModule: z.ZodLiteral<"mlp.down_proj.weight">;
+                    factToken: z.ZodLiteral<"subject_last">;
+                    layers: z.ZodArray<z.ZodNumber>;
+                    lossLayer: z.ZodNumber;
+                    contextTemplateGroups: z.ZodArray<z.ZodArray<z.ZodString>>;
+                    nullspaceThreshold: z.ZodNumber;
+                    l2: z.ZodNumber;
+                    covariance: z.ZodLiteral<"non_padding_uncentered_second_moment_fp32_v1">;
+                    projector: z.ZodLiteral<"covariance_svd_below_absolute_threshold_v1">;
+                    sequentialState: z.ZodLiteral<"post_edit_group_mean_keys_outer_product_sum_v1">;
+                    targetTokenization: z.ZodLiteral<"leading_space_no_special_tokens_v1">;
+                }, z.core.$strict>;
+                pins: z.ZodObject<{
+                    baseModel: 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>;
+                    configHash: z.ZodString;
+                    recipeHash: z.ZodString;
+                    dataHash: z.ZodString;
+                    data: z.ZodObject<{
+                        edits: z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                        }, z.core.$strict>;
+                        preservation: z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>;
+                    runtimeHash: z.ZodString;
+                    parentArtifactHash: z.ZodNullable<z.ZodString>;
+                    preservationModelHash: z.ZodString;
+                }, z.core.$strict>;
+                representation: z.ZodLiteral<"exact_replacement_bf16_down_proj_matrices_v1">;
+                payloads: z.ZodObject<{
+                    patch: z.ZodObject<{
+                        sha256: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        tensors: z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            shape: z.ZodArray<z.ZodNumber>;
+                            dtype: z.ZodEnum<{
+                                BF16: "BF16";
+                                F32: "F32";
+                            }>;
+                        }, z.core.$strict>>;
+                        path: z.ZodLiteral<"patch.safetensors">;
+                    }, z.core.$strict>;
+                    state: z.ZodArray<z.ZodObject<{
+                        sha256: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        tensors: z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            shape: z.ZodArray<z.ZodNumber>;
+                            dtype: z.ZodEnum<{
+                                BF16: "BF16";
+                                F32: "F32";
+                            }>;
+                        }, z.core.$strict>>;
+                        path: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodUnion<readonly [z.ZodEnum<{
+                    "manifest.json": "manifest.json";
+                    "patch.safetensors": "patch.safetensors";
+                }>, z.ZodString]>;
+                artifactId: z.ZodString;
+                sha256: z.ZodString;
+                sizeBytes: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const AlphaEditResultSaveReceiptSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    model: z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        portableProjectId: z.ZodString;
+        name: z.ZodString;
+        objective: z.ZodNullable<z.ZodString>;
+        defaultBaseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        defaultDestinationId: z.ZodNullable<z.ZodString>;
+        trainingSetup: z.ZodObject<{
+            tasksetRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            evaluationTasksetRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            profileSource: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            profileEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                tasksetRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            rewardBindingRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            tasksetRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            harnessRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            baseModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+                tokenizerRevision: z.ZodNullable<z.ZodString>;
+                chatTemplateHash: z.ZodNullable<z.ZodString>;
+                modelAssetId: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    builtin: "builtin";
+                    local: "local";
+                    managed: "managed";
+                }>;
+            }, z.core.$strict>>>;
+            method: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                dpo: "dpo";
+                grpo: "grpo";
+                opd: "opd";
+                opsd: "opsd";
+                ppo: "ppo";
+                sdft: "sdft";
+                sdpo: "sdpo";
+                sft: "sft";
+            }>>>;
+            destinationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            managedRolloutPlacement: z.ZodDefault<z.ZodEnum<{
+                local: "local";
+                remote: "remote";
+            }>>;
+            managedGpuPlacementObjective: z.ZodDefault<z.ZodEnum<{
+                balanced: "balanced";
+                economical: "economical";
+                fast: "fast";
+            }>>;
+            managedGpuSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"automatic">;
+                objective: z.ZodEnum<{
+                    balanced: "balanced";
+                    economical: "economical";
+                    fast: "fast";
+                }>;
+                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"manual">;
+                availabilityId: z.ZodString;
+                gpuType: z.ZodString;
+                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+            }, z.core.$strict>], "mode">>;
+            continuationAdapterMode: z.ZodOptional<z.ZodEnum<{
+                residual_append: "residual_append";
+                sequential_merge: "sequential_merge";
+                shared: "shared";
+            }>>;
+            managedGpuRequirement: z.ZodDefault<z.ZodEnum<{
+                any: "any";
+                h100_hbm3: "h100_hbm3";
+            }>>;
+            runPreset: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                custom: "custom";
+                small: "small";
+                small_experiment: "small_experiment";
+                standard: "standard";
+            }>>>;
+            recipe: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodString;
+                method: z.ZodEnum<{
+                    dpo: "dpo";
+                    grpo: "grpo";
+                    opd: "opd";
+                    opsd: "opsd";
+                    ppo: "ppo";
+                    sdft: "sdft";
+                    sdpo: "sdpo";
+                    sft: "sft";
+                }>;
+                parameterization: z.ZodEnum<{
+                    full: "full";
+                    lora: "lora";
+                }>;
+            }, z.core.$catchall<z.ZodUnknown>>>>;
+            preferredMaximumSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            preferredRetentionDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>;
+        sourceRevision: z.ZodNumber;
+        sourceUpdatedAt: z.ZodString;
+        revision: z.ZodNumber;
+        etag: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<"openpond.alphaEditResultSaveReceipt.v1">;
+    version: z.ZodObject<{
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        modelProjectId: z.ZodString;
+        portableProjectId: z.ZodString;
+        baseModel: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>;
+        source: z.ZodObject<{
+            executionId: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            resultHash: z.ZodString;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+        schemaVersion: z.ZodLiteral<"openpond.alphaEditModelVersion.v1">;
+        request: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.alphaEditTrainingRequest.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>;
+            data: z.ZodObject<{
+                edits: z.ZodObject<{
+                    batch: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    examplesSha256: z.ZodString;
+                }, z.core.$strict>;
+                preservation: z.ZodObject<{
+                    batch: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    examplesSha256: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            config: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.alphaEditConfig.v1">;
+                implementation: z.ZodLiteral<"openpond_qwen_alphaedit_v1">;
+                sourceRevision: z.ZodLiteral<"b84624f44dfe8fc6cd9e41df916c44124a0c46dc">;
+                rewriteModule: z.ZodLiteral<"mlp.down_proj.weight">;
+                factToken: z.ZodLiteral<"subject_last">;
+                layers: z.ZodArray<z.ZodNumber>;
+                lossLayer: z.ZodNumber;
+                contextTemplateGroups: z.ZodArray<z.ZodArray<z.ZodString>>;
+                nullspaceThreshold: z.ZodNumber;
+                l2: z.ZodNumber;
+                covariance: z.ZodLiteral<"non_padding_uncentered_second_moment_fp32_v1">;
+                projector: z.ZodLiteral<"covariance_svd_below_absolute_threshold_v1">;
+                sequentialState: z.ZodLiteral<"post_edit_group_mean_keys_outer_product_sum_v1">;
+                targetTokenization: z.ZodLiteral<"leading_space_no_special_tokens_v1">;
+            }, z.core.$strict>;
+            training: z.ZodObject<{
+                maxSteps: z.ZodNumber;
+                learningRate: z.ZodNumber;
+                klFactor: z.ZodNumber;
+                latentWeightDecay: z.ZodNumber;
+                clampNormFactor: z.ZodNumber;
+                maxSequenceLength: z.ZodNumber;
+                maxDurationSeconds: z.ZodNumber;
+                maxForwardTokenWork: z.ZodNumber;
+                maxCheckpointBytes: z.ZodNumber;
+                seed: z.ZodNumber;
+            }, z.core.$strict>;
+            parentArtifact: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        artifact: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            manifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.alphaEditArtifact.v1">;
+                method: z.ZodLiteral<"alphaedit">;
+                config: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.alphaEditConfig.v1">;
+                    implementation: z.ZodLiteral<"openpond_qwen_alphaedit_v1">;
+                    sourceRevision: z.ZodLiteral<"b84624f44dfe8fc6cd9e41df916c44124a0c46dc">;
+                    rewriteModule: z.ZodLiteral<"mlp.down_proj.weight">;
+                    factToken: z.ZodLiteral<"subject_last">;
+                    layers: z.ZodArray<z.ZodNumber>;
+                    lossLayer: z.ZodNumber;
+                    contextTemplateGroups: z.ZodArray<z.ZodArray<z.ZodString>>;
+                    nullspaceThreshold: z.ZodNumber;
+                    l2: z.ZodNumber;
+                    covariance: z.ZodLiteral<"non_padding_uncentered_second_moment_fp32_v1">;
+                    projector: z.ZodLiteral<"covariance_svd_below_absolute_threshold_v1">;
+                    sequentialState: z.ZodLiteral<"post_edit_group_mean_keys_outer_product_sum_v1">;
+                    targetTokenization: z.ZodLiteral<"leading_space_no_special_tokens_v1">;
+                }, z.core.$strict>;
+                pins: z.ZodObject<{
+                    baseModel: 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>;
+                    configHash: z.ZodString;
+                    recipeHash: z.ZodString;
+                    dataHash: z.ZodString;
+                    data: z.ZodObject<{
+                        edits: z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                        }, z.core.$strict>;
+                        preservation: z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>;
+                    runtimeHash: z.ZodString;
+                    parentArtifactHash: z.ZodNullable<z.ZodString>;
+                    preservationModelHash: z.ZodString;
+                }, z.core.$strict>;
+                representation: z.ZodLiteral<"exact_replacement_bf16_down_proj_matrices_v1">;
+                payloads: z.ZodObject<{
+                    patch: z.ZodObject<{
+                        sha256: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        tensors: z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            shape: z.ZodArray<z.ZodNumber>;
+                            dtype: z.ZodEnum<{
+                                BF16: "BF16";
+                                F32: "F32";
+                            }>;
+                        }, z.core.$strict>>;
+                        path: z.ZodLiteral<"patch.safetensors">;
+                    }, z.core.$strict>;
+                    state: z.ZodArray<z.ZodObject<{
+                        sha256: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        tensors: z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            shape: z.ZodArray<z.ZodNumber>;
+                            dtype: z.ZodEnum<{
+                                BF16: "BF16";
+                                F32: "F32";
+                            }>;
+                        }, z.core.$strict>>;
+                        path: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodUnion<readonly [z.ZodEnum<{
+                    "manifest.json": "manifest.json";
+                    "patch.safetensors": "patch.safetensors";
+                }>, z.ZodString]>;
+                artifactId: z.ZodString;
+                sha256: z.ZodString;
+                sizeBytes: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type AlphaEditResultSaveReceipt = z.infer<typeof AlphaEditResultSaveReceiptSchema>;
+export declare const NeuronTrainingResultSaveReceiptContentSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    model: z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        portableProjectId: z.ZodString;
+        name: z.ZodString;
+        objective: z.ZodNullable<z.ZodString>;
+        defaultBaseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        defaultDestinationId: z.ZodNullable<z.ZodString>;
+        trainingSetup: z.ZodObject<{
+            tasksetRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            evaluationTasksetRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            profileSource: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            profileEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                tasksetRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            rewardBindingRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            tasksetRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            harnessRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            baseModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+                tokenizerRevision: z.ZodNullable<z.ZodString>;
+                chatTemplateHash: z.ZodNullable<z.ZodString>;
+                modelAssetId: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    builtin: "builtin";
+                    local: "local";
+                    managed: "managed";
+                }>;
+            }, z.core.$strict>>>;
+            method: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                dpo: "dpo";
+                grpo: "grpo";
+                opd: "opd";
+                opsd: "opsd";
+                ppo: "ppo";
+                sdft: "sdft";
+                sdpo: "sdpo";
+                sft: "sft";
+            }>>>;
+            destinationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            managedRolloutPlacement: z.ZodDefault<z.ZodEnum<{
+                local: "local";
+                remote: "remote";
+            }>>;
+            managedGpuPlacementObjective: z.ZodDefault<z.ZodEnum<{
+                balanced: "balanced";
+                economical: "economical";
+                fast: "fast";
+            }>>;
+            managedGpuSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"automatic">;
+                objective: z.ZodEnum<{
+                    balanced: "balanced";
+                    economical: "economical";
+                    fast: "fast";
+                }>;
+                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"manual">;
+                availabilityId: z.ZodString;
+                gpuType: z.ZodString;
+                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+            }, z.core.$strict>], "mode">>;
+            continuationAdapterMode: z.ZodOptional<z.ZodEnum<{
+                residual_append: "residual_append";
+                sequential_merge: "sequential_merge";
+                shared: "shared";
+            }>>;
+            managedGpuRequirement: z.ZodDefault<z.ZodEnum<{
+                any: "any";
+                h100_hbm3: "h100_hbm3";
+            }>>;
+            runPreset: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                custom: "custom";
+                small: "small";
+                small_experiment: "small_experiment";
+                standard: "standard";
+            }>>>;
+            recipe: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodString;
+                method: z.ZodEnum<{
+                    dpo: "dpo";
+                    grpo: "grpo";
+                    opd: "opd";
+                    opsd: "opsd";
+                    ppo: "ppo";
+                    sdft: "sdft";
+                    sdpo: "sdpo";
+                    sft: "sft";
+                }>;
+                parameterization: z.ZodEnum<{
+                    full: "full";
+                    lora: "lora";
+                }>;
+            }, z.core.$catchall<z.ZodUnknown>>>>;
+            preferredMaximumSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            preferredRetentionDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>;
+        sourceRevision: z.ZodNumber;
+        sourceUpdatedAt: z.ZodString;
+        revision: z.ZodNumber;
+        etag: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingResultSaveReceipt.v1">;
+    version: z.ZodObject<{
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        modelProjectId: z.ZodString;
+        portableProjectId: z.ZodString;
+        baseModel: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>;
+        source: z.ZodObject<{
+            executionId: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            resultHash: z.ZodString;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+        schemaVersion: z.ZodLiteral<"openpond.neuronTrainingModelVersion.v1">;
+        request: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.selectiveNeuronTrainingRequest.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>;
+            data: z.ZodObject<{
+                target: z.ZodObject<{
+                    batch: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    examplesSha256: z.ZodString;
+                    encodingHash: z.ZodString;
+                }, z.core.$strict>;
+                background: z.ZodArray<z.ZodObject<{
+                    batch: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    examplesSha256: z.ZodString;
+                    encodingHash: z.ZodString;
+                    domain: z.ZodString;
+                }, z.core.$strict>>;
+                preservation: z.ZodNullable<z.ZodObject<{
+                    batch: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    examplesSha256: z.ZodString;
+                    encodingHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            selection: z.ZodObject<{
+                count: z.ZodNumber;
+                span: z.ZodEnum<{
+                    prompt: "prompt";
+                    reply_prediction: "reply_prediction";
+                    reply_start: "reply_start";
+                }>;
+                backgroundStatistic: z.ZodEnum<{
+                    max_domains: "max_domains";
+                    mean_domains: "mean_domains";
+                }>;
+                maximumBackgroundTargetRatio: z.ZodNumber;
+                gradientExamples: z.ZodNumber;
+                explicitCoordinates: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    neuron: z.ZodNumber;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            training: z.ZodObject<{
+                learningRate: z.ZodNumber;
+                maxSteps: z.ZodNumber;
+                gradientAccumulationSteps: z.ZodNumber;
+                maxSequenceLength: z.ZodNumber;
+                preservationWeight: z.ZodNumber;
+                preservationExamplesPerStep: z.ZodNumber;
+                seed: z.ZodNumber;
+                maxDurationSeconds: z.ZodNumber;
+                maxCheckpointBytes: z.ZodNumber;
+                maximumForwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>;
+            parentArtifact: z.ZodNull;
+        }, z.core.$strict>;
+        artifact: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            manifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronTrainingArtifact.v1">;
+                method: z.ZodLiteral<"selective_neuron_training">;
+                algorithm: z.ZodObject<{
+                    implementation: z.ZodLiteral<"openpond_qwen3_selective_columns_v1">;
+                    upstream: z.ZodLiteral<"changjonathanc/neuron-tuning">;
+                    revision: z.ZodLiteral<"8a55f3159f735eb0823d7a894f67f632bf568bb3">;
+                    license: z.ZodLiteral<"Apache-2.0">;
+                    hook: z.ZodLiteral<"mlp.down_proj">;
+                    operation: z.ZodLiteral<"output_plus_selected_input_times_delta_v1">;
+                    parameterization: z.ZodLiteral<"column_gain_rms_direction_v1">;
+                    activityQuantile: z.ZodLiteral<0.9>;
+                    backgroundFloor: z.ZodLiteral<0.000001>;
+                    gradientSubsetSeed: z.ZodLiteral<0>;
+                    optimizer: z.ZodLiteral<"Adam">;
+                    betas: z.ZodTuple<[z.ZodLiteral<0.9>, z.ZodLiteral<0.999>], null>;
+                    epsilon: z.ZodLiteral<1e-8>;
+                    weightDecay: z.ZodLiteral<0>;
+                    gradientClipNorm: z.ZodLiteral<1>;
+                    batchSize: z.ZodLiteral<1>;
+                    parameterDtype: z.ZodLiteral<"float32">;
+                    resume: z.ZodLiteral<"unsupported">;
+                }, z.core.$strict>;
+                pins: z.ZodObject<{
+                    baseModel: 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>;
+                    inputHash: z.ZodString;
+                    data: z.ZodObject<{
+                        target: z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                        }, z.core.$strict>;
+                        background: z.ZodArray<z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                            domain: z.ZodString;
+                        }, z.core.$strict>>;
+                        preservation: z.ZodNullable<z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>;
+                    dataHash: z.ZodString;
+                    selectionConfigHash: z.ZodString;
+                    trainingConfigHash: z.ZodString;
+                    runtimeHash: z.ZodString;
+                    parentArtifactHash: z.ZodNull;
+                }, z.core.$strict>;
+                selection: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+                    modelHash: z.ZodString;
+                    dataHash: z.ZodString;
+                    selectionConfigHash: z.ZodString;
+                    preparedRowsHash: z.ZodString;
+                    source: z.ZodEnum<{
+                        automatic: "automatic";
+                        explicit: "explicit";
+                    }>;
+                    targetExampleIds: z.ZodArray<z.ZodString>;
+                    eligibleCount: z.ZodNumber;
+                    entries: z.ZodArray<z.ZodObject<{
+                        layer: z.ZodNumber;
+                        neuron: z.ZodNumber;
+                        targetMeanAbsolute: z.ZodNumber;
+                        backgroundMeanAbsolute: z.ZodNumber;
+                        backgroundTargetRatio: z.ZodNumber;
+                        gradientNorm: z.ZodNumber;
+                        score: z.ZodNumber;
+                        targetActivityThreshold: z.ZodNumber;
+                        backgroundByDomain: z.ZodArray<z.ZodObject<{
+                            domainIndex: z.ZodNumber;
+                            meanAbsolute: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                payload: z.ZodObject<{
+                    path: z.ZodLiteral<"patch.safetensors">;
+                    sha256: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    tensors: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        dtype: z.ZodEnum<{
+                            F32: "F32";
+                            I64: "I64";
+                        }>;
+                        shape: z.ZodArray<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodEnum<{
+                    "manifest.json": "manifest.json";
+                    "patch.safetensors": "patch.safetensors";
+                }>;
+                artifactId: z.ZodString;
+                sha256: z.ZodString;
+                sizeBytes: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const NeuronTrainingResultSaveReceiptSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    model: z.ZodObject<{
+        id: z.ZodString;
+        teamId: z.ZodString;
+        portableProjectId: z.ZodString;
+        name: z.ZodString;
+        objective: z.ZodNullable<z.ZodString>;
+        defaultBaseModel: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>>;
+        defaultDestinationId: z.ZodNullable<z.ZodString>;
+        trainingSetup: z.ZodObject<{
+            tasksetRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            evaluationTasksetRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            profileSource: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            profileEvaluation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                profileProjectId: z.ZodString;
+                sourceRevision: z.ZodString;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                tasksetRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>>;
+            rewardBindingRef: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>>;
+            tasksetRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            harnessRelease: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+            baseModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+                tokenizerRevision: z.ZodNullable<z.ZodString>;
+                chatTemplateHash: z.ZodNullable<z.ZodString>;
+                modelAssetId: z.ZodNullable<z.ZodString>;
+                source: z.ZodEnum<{
+                    builtin: "builtin";
+                    local: "local";
+                    managed: "managed";
+                }>;
+            }, z.core.$strict>>>;
+            method: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                dpo: "dpo";
+                grpo: "grpo";
+                opd: "opd";
+                opsd: "opsd";
+                ppo: "ppo";
+                sdft: "sdft";
+                sdpo: "sdpo";
+                sft: "sft";
+            }>>>;
+            destinationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            managedRolloutPlacement: z.ZodDefault<z.ZodEnum<{
+                local: "local";
+                remote: "remote";
+            }>>;
+            managedGpuPlacementObjective: z.ZodDefault<z.ZodEnum<{
+                balanced: "balanced";
+                economical: "economical";
+                fast: "fast";
+            }>>;
+            managedGpuSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"automatic">;
+                objective: z.ZodEnum<{
+                    balanced: "balanced";
+                    economical: "economical";
+                    fast: "fast";
+                }>;
+                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+            }, z.core.$strict>, z.ZodObject<{
+                mode: z.ZodLiteral<"manual">;
+                availabilityId: z.ZodString;
+                gpuType: z.ZodString;
+                gpuCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+            }, z.core.$strict>], "mode">>;
+            continuationAdapterMode: z.ZodOptional<z.ZodEnum<{
+                residual_append: "residual_append";
+                sequential_merge: "sequential_merge";
+                shared: "shared";
+            }>>;
+            managedGpuRequirement: z.ZodDefault<z.ZodEnum<{
+                any: "any";
+                h100_hbm3: "h100_hbm3";
+            }>>;
+            runPreset: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                custom: "custom";
+                small: "small";
+                small_experiment: "small_experiment";
+                standard: "standard";
+            }>>>;
+            recipe: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodString;
+                method: z.ZodEnum<{
+                    dpo: "dpo";
+                    grpo: "grpo";
+                    opd: "opd";
+                    opsd: "opsd";
+                    ppo: "ppo";
+                    sdft: "sdft";
+                    sdpo: "sdpo";
+                    sft: "sft";
+                }>;
+                parameterization: z.ZodEnum<{
+                    full: "full";
+                    lora: "lora";
+                }>;
+            }, z.core.$catchall<z.ZodUnknown>>>>;
+            preferredMaximumSpendUsd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            preferredRetentionDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>;
+        sourceRevision: z.ZodNumber;
+        sourceUpdatedAt: z.ZodString;
+        revision: z.ZodNumber;
+        etag: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingResultSaveReceipt.v1">;
+    version: z.ZodObject<{
+        teamId: z.ZodString;
+        ownerUserId: z.ZodString;
+        modelProjectId: z.ZodString;
+        portableProjectId: z.ZodString;
+        baseModel: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+            tokenizerRevision: z.ZodNullable<z.ZodString>;
+            chatTemplateHash: z.ZodNullable<z.ZodString>;
+            modelAssetId: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                builtin: "builtin";
+                local: "local";
+                managed: "managed";
+            }>;
+        }, z.core.$strict>;
+        source: z.ZodObject<{
+            executionId: z.ZodString;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            resultHash: z.ZodString;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+        schemaVersion: z.ZodLiteral<"openpond.neuronTrainingModelVersion.v1">;
+        request: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.selectiveNeuronTrainingRequest.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>;
+            data: z.ZodObject<{
+                target: z.ZodObject<{
+                    batch: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    examplesSha256: z.ZodString;
+                    encodingHash: z.ZodString;
+                }, z.core.$strict>;
+                background: z.ZodArray<z.ZodObject<{
+                    batch: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    examplesSha256: z.ZodString;
+                    encodingHash: z.ZodString;
+                    domain: z.ZodString;
+                }, z.core.$strict>>;
+                preservation: z.ZodNullable<z.ZodObject<{
+                    batch: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    examplesSha256: z.ZodString;
+                    encodingHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            selection: z.ZodObject<{
+                count: z.ZodNumber;
+                span: z.ZodEnum<{
+                    prompt: "prompt";
+                    reply_prediction: "reply_prediction";
+                    reply_start: "reply_start";
+                }>;
+                backgroundStatistic: z.ZodEnum<{
+                    max_domains: "max_domains";
+                    mean_domains: "mean_domains";
+                }>;
+                maximumBackgroundTargetRatio: z.ZodNumber;
+                gradientExamples: z.ZodNumber;
+                explicitCoordinates: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    neuron: z.ZodNumber;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+            training: z.ZodObject<{
+                learningRate: z.ZodNumber;
+                maxSteps: z.ZodNumber;
+                gradientAccumulationSteps: z.ZodNumber;
+                maxSequenceLength: z.ZodNumber;
+                preservationWeight: z.ZodNumber;
+                preservationExamplesPerStep: z.ZodNumber;
+                seed: z.ZodNumber;
+                maxDurationSeconds: z.ZodNumber;
+                maxCheckpointBytes: z.ZodNumber;
+                maximumForwardTokenWork: z.ZodNumber;
+            }, z.core.$strict>;
+            parentArtifact: z.ZodNull;
+        }, z.core.$strict>;
+        artifact: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            manifest: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronTrainingArtifact.v1">;
+                method: z.ZodLiteral<"selective_neuron_training">;
+                algorithm: z.ZodObject<{
+                    implementation: z.ZodLiteral<"openpond_qwen3_selective_columns_v1">;
+                    upstream: z.ZodLiteral<"changjonathanc/neuron-tuning">;
+                    revision: z.ZodLiteral<"8a55f3159f735eb0823d7a894f67f632bf568bb3">;
+                    license: z.ZodLiteral<"Apache-2.0">;
+                    hook: z.ZodLiteral<"mlp.down_proj">;
+                    operation: z.ZodLiteral<"output_plus_selected_input_times_delta_v1">;
+                    parameterization: z.ZodLiteral<"column_gain_rms_direction_v1">;
+                    activityQuantile: z.ZodLiteral<0.9>;
+                    backgroundFloor: z.ZodLiteral<0.000001>;
+                    gradientSubsetSeed: z.ZodLiteral<0>;
+                    optimizer: z.ZodLiteral<"Adam">;
+                    betas: z.ZodTuple<[z.ZodLiteral<0.9>, z.ZodLiteral<0.999>], null>;
+                    epsilon: z.ZodLiteral<1e-8>;
+                    weightDecay: z.ZodLiteral<0>;
+                    gradientClipNorm: z.ZodLiteral<1>;
+                    batchSize: z.ZodLiteral<1>;
+                    parameterDtype: z.ZodLiteral<"float32">;
+                    resume: z.ZodLiteral<"unsupported">;
+                }, z.core.$strict>;
+                pins: z.ZodObject<{
+                    baseModel: 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>;
+                    inputHash: z.ZodString;
+                    data: z.ZodObject<{
+                        target: z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                        }, z.core.$strict>;
+                        background: z.ZodArray<z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                            domain: z.ZodString;
+                        }, z.core.$strict>>;
+                        preservation: z.ZodNullable<z.ZodObject<{
+                            batch: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodNumber;
+                            }, z.core.$strict>;
+                            examplesSha256: z.ZodString;
+                            encodingHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>;
+                    dataHash: z.ZodString;
+                    selectionConfigHash: z.ZodString;
+                    trainingConfigHash: z.ZodString;
+                    runtimeHash: z.ZodString;
+                    parentArtifactHash: z.ZodNull;
+                }, z.core.$strict>;
+                selection: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+                    modelHash: z.ZodString;
+                    dataHash: z.ZodString;
+                    selectionConfigHash: z.ZodString;
+                    preparedRowsHash: z.ZodString;
+                    source: z.ZodEnum<{
+                        automatic: "automatic";
+                        explicit: "explicit";
+                    }>;
+                    targetExampleIds: z.ZodArray<z.ZodString>;
+                    eligibleCount: z.ZodNumber;
+                    entries: z.ZodArray<z.ZodObject<{
+                        layer: z.ZodNumber;
+                        neuron: z.ZodNumber;
+                        targetMeanAbsolute: z.ZodNumber;
+                        backgroundMeanAbsolute: z.ZodNumber;
+                        backgroundTargetRatio: z.ZodNumber;
+                        gradientNorm: z.ZodNumber;
+                        score: z.ZodNumber;
+                        targetActivityThreshold: z.ZodNumber;
+                        backgroundByDomain: z.ZodArray<z.ZodObject<{
+                            domainIndex: z.ZodNumber;
+                            meanAbsolute: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                payload: z.ZodObject<{
+                    path: z.ZodLiteral<"patch.safetensors">;
+                    sha256: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    tensors: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        dtype: z.ZodEnum<{
+                            F32: "F32";
+                            I64: "I64";
+                        }>;
+                        shape: z.ZodArray<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodEnum<{
+                    "manifest.json": "manifest.json";
+                    "patch.safetensors": "patch.safetensors";
+                }>;
+                artifactId: z.ZodString;
+                sha256: z.ZodString;
+                sizeBytes: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronTrainingResultSaveReceipt = z.infer<typeof NeuronTrainingResultSaveReceiptSchema>;
+export declare function parseAndVerifyAlphaEditResultSaveReceipt(raw: unknown, input: AlphaEditResultSaveRequest): Promise<{
+    teamId: string;
+    actorId: string;
+    operationId: string;
+    requestHash: string;
+    model: {
+        id: string;
+        teamId: string;
+        portableProjectId: string;
+        name: string;
+        objective: string | null;
+        defaultBaseModel: {
+            schemaVersion: "openpond.baseModelPreference.v1";
+            modelId: string;
+            revision: string | null;
+            tokenizerRevision: string | null;
+            chatTemplateHash: string | null;
+            modelAssetId: string | null;
+            source: "builtin" | "local" | "managed";
+        } | null;
+        defaultDestinationId: string | null;
+        trainingSetup: {
+            tasksetRef: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+            evaluationTasksetRef?: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null | undefined;
+            profileSource?: {
+                profileProjectId: string;
+                sourceRevision: string;
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+            } | null | undefined;
+            profileEvaluation?: {
+                profileProjectId: string;
+                sourceRevision: string;
+                catalogHash: string;
+                definitionId: string;
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                tasksetRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+            } | null | undefined;
+            rewardBindingRef?: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null | undefined;
+            tasksetRelease: {
+                id: string;
+                contentHash: string;
+            } | null;
+            harnessRelease: {
+                id: string;
+                contentHash: string;
+            } | null;
+            baseModel: {
+                schemaVersion: "openpond.baseModelPreference.v1";
+                modelId: string;
+                revision: string | null;
+                tokenizerRevision: string | null;
+                chatTemplateHash: string | null;
+                modelAssetId: string | null;
+                source: "builtin" | "local" | "managed";
+            } | null;
+            method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft" | null;
+            destinationId: string | null;
+            managedRolloutPlacement: "local" | "remote";
+            managedGpuPlacementObjective: "balanced" | "economical" | "fast";
+            managedGpuSelection?: {
+                mode: "automatic";
+                objective: "balanced" | "economical" | "fast";
+                gpuCount?: 1 | 2 | undefined;
+            } | {
+                mode: "manual";
+                availabilityId: string;
+                gpuType: string;
+                gpuCount?: 1 | 2 | undefined;
+            } | undefined;
+            continuationAdapterMode?: "residual_append" | "sequential_merge" | "shared" | undefined;
+            managedGpuRequirement: "any" | "h100_hbm3";
+            runPreset: "custom" | "small" | "small_experiment" | "standard" | null;
+            recipe: {
+                [x: string]: unknown;
+                schemaVersion: string;
+                method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft";
+                parameterization: "full" | "lora";
+            } | null;
+            preferredMaximumSpendUsd: number | null;
+            preferredRetentionDays: number | null;
+        };
+        sourceRevision: number;
+        sourceUpdatedAt: string;
+        revision: number;
+        etag: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+    schemaVersion: "openpond.alphaEditResultSaveReceipt.v1";
+    version: {
+        teamId: string;
+        ownerUserId: string;
+        modelProjectId: string;
+        portableProjectId: string;
+        baseModel: {
+            schemaVersion: "openpond.baseModelPreference.v1";
+            modelId: string;
+            revision: string | null;
+            tokenizerRevision: string | null;
+            chatTemplateHash: string | null;
+            modelAssetId: string | null;
+            source: "builtin" | "local" | "managed";
+        };
+        source: {
+            executionId: string;
+            inputHash: string;
+            runtimeHash: string;
+            resultHash: string;
+        };
+        createdAt: string;
+        schemaVersion: "openpond.alphaEditModelVersion.v1";
+        request: {
+            schemaVersion: "openpond.alphaEditTrainingRequest.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[];
+            };
+            data: {
+                edits: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                };
+                preservation: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                };
+            };
+            config: {
+                schemaVersion: "openpond.alphaEditConfig.v1";
+                implementation: "openpond_qwen_alphaedit_v1";
+                sourceRevision: "b84624f44dfe8fc6cd9e41df916c44124a0c46dc";
+                rewriteModule: "mlp.down_proj.weight";
+                factToken: "subject_last";
+                layers: number[];
+                lossLayer: number;
+                contextTemplateGroups: string[][];
+                nullspaceThreshold: number;
+                l2: number;
+                covariance: "non_padding_uncentered_second_moment_fp32_v1";
+                projector: "covariance_svd_below_absolute_threshold_v1";
+                sequentialState: "post_edit_group_mean_keys_outer_product_sum_v1";
+                targetTokenization: "leading_space_no_special_tokens_v1";
+            };
+            training: {
+                maxSteps: number;
+                learningRate: number;
+                klFactor: number;
+                latentWeightDecay: number;
+                clampNormFactor: number;
+                maxSequenceLength: number;
+                maxDurationSeconds: number;
+                maxForwardTokenWork: number;
+                maxCheckpointBytes: number;
+                seed: number;
+            };
+            parentArtifact: {
+                id: string;
+                contentHash: string;
+            } | null;
+        };
+        artifact: {
+            id: string;
+            contentHash: string;
+            manifest: {
+                schemaVersion: "openpond.alphaEditArtifact.v1";
+                method: "alphaedit";
+                config: {
+                    schemaVersion: "openpond.alphaEditConfig.v1";
+                    implementation: "openpond_qwen_alphaedit_v1";
+                    sourceRevision: "b84624f44dfe8fc6cd9e41df916c44124a0c46dc";
+                    rewriteModule: "mlp.down_proj.weight";
+                    factToken: "subject_last";
+                    layers: number[];
+                    lossLayer: number;
+                    contextTemplateGroups: string[][];
+                    nullspaceThreshold: number;
+                    l2: number;
+                    covariance: "non_padding_uncentered_second_moment_fp32_v1";
+                    projector: "covariance_svd_below_absolute_threshold_v1";
+                    sequentialState: "post_edit_group_mean_keys_outer_product_sum_v1";
+                    targetTokenization: "leading_space_no_special_tokens_v1";
+                };
+                pins: {
+                    baseModel: {
+                        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[];
+                    };
+                    configHash: string;
+                    recipeHash: string;
+                    dataHash: string;
+                    data: {
+                        edits: {
+                            batch: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                            examplesSha256: string;
+                        };
+                        preservation: {
+                            batch: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                            examplesSha256: string;
+                        };
+                    };
+                    runtimeHash: string;
+                    parentArtifactHash: string | null;
+                    preservationModelHash: string;
+                };
+                representation: "exact_replacement_bf16_down_proj_matrices_v1";
+                payloads: {
+                    patch: {
+                        sha256: string;
+                        sizeBytes: number;
+                        tensors: {
+                            name: string;
+                            shape: number[];
+                            dtype: "BF16" | "F32";
+                        }[];
+                        path: "patch.safetensors";
+                    };
+                    state: {
+                        sha256: string;
+                        sizeBytes: number;
+                        tensors: {
+                            name: string;
+                            shape: number[];
+                            dtype: "BF16" | "F32";
+                        }[];
+                        path: string;
+                    }[];
+                };
+                contentHash: string;
+            };
+            files: {
+                path: string;
+                artifactId: string;
+                sha256: string;
+                sizeBytes: number;
+            }[];
+        };
+        contentHash: string;
+    };
+    contentHash: string;
+}>;
+export declare function parseAndVerifyNeuronTrainingResultSaveReceipt(raw: unknown, input: NeuronTrainingResultSaveRequest): Promise<{
+    teamId: string;
+    actorId: string;
+    operationId: string;
+    requestHash: string;
+    model: {
+        id: string;
+        teamId: string;
+        portableProjectId: string;
+        name: string;
+        objective: string | null;
+        defaultBaseModel: {
+            schemaVersion: "openpond.baseModelPreference.v1";
+            modelId: string;
+            revision: string | null;
+            tokenizerRevision: string | null;
+            chatTemplateHash: string | null;
+            modelAssetId: string | null;
+            source: "builtin" | "local" | "managed";
+        } | null;
+        defaultDestinationId: string | null;
+        trainingSetup: {
+            tasksetRef: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+            evaluationTasksetRef?: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null | undefined;
+            profileSource?: {
+                profileProjectId: string;
+                sourceRevision: string;
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+            } | null | undefined;
+            profileEvaluation?: {
+                profileProjectId: string;
+                sourceRevision: string;
+                catalogHash: string;
+                definitionId: string;
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                tasksetRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+            } | null | undefined;
+            rewardBindingRef?: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null | undefined;
+            tasksetRelease: {
+                id: string;
+                contentHash: string;
+            } | null;
+            harnessRelease: {
+                id: string;
+                contentHash: string;
+            } | null;
+            baseModel: {
+                schemaVersion: "openpond.baseModelPreference.v1";
+                modelId: string;
+                revision: string | null;
+                tokenizerRevision: string | null;
+                chatTemplateHash: string | null;
+                modelAssetId: string | null;
+                source: "builtin" | "local" | "managed";
+            } | null;
+            method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft" | null;
+            destinationId: string | null;
+            managedRolloutPlacement: "local" | "remote";
+            managedGpuPlacementObjective: "balanced" | "economical" | "fast";
+            managedGpuSelection?: {
+                mode: "automatic";
+                objective: "balanced" | "economical" | "fast";
+                gpuCount?: 1 | 2 | undefined;
+            } | {
+                mode: "manual";
+                availabilityId: string;
+                gpuType: string;
+                gpuCount?: 1 | 2 | undefined;
+            } | undefined;
+            continuationAdapterMode?: "residual_append" | "sequential_merge" | "shared" | undefined;
+            managedGpuRequirement: "any" | "h100_hbm3";
+            runPreset: "custom" | "small" | "small_experiment" | "standard" | null;
+            recipe: {
+                [x: string]: unknown;
+                schemaVersion: string;
+                method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft";
+                parameterization: "full" | "lora";
+            } | null;
+            preferredMaximumSpendUsd: number | null;
+            preferredRetentionDays: number | null;
+        };
+        sourceRevision: number;
+        sourceUpdatedAt: string;
+        revision: number;
+        etag: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+    schemaVersion: "openpond.neuronTrainingResultSaveReceipt.v1";
+    version: {
+        teamId: string;
+        ownerUserId: string;
+        modelProjectId: string;
+        portableProjectId: string;
+        baseModel: {
+            schemaVersion: "openpond.baseModelPreference.v1";
+            modelId: string;
+            revision: string | null;
+            tokenizerRevision: string | null;
+            chatTemplateHash: string | null;
+            modelAssetId: string | null;
+            source: "builtin" | "local" | "managed";
+        };
+        source: {
+            executionId: string;
+            inputHash: string;
+            runtimeHash: string;
+            resultHash: string;
+        };
+        createdAt: string;
+        schemaVersion: "openpond.neuronTrainingModelVersion.v1";
+        request: {
+            schemaVersion: "openpond.selectiveNeuronTrainingRequest.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[];
+            };
+            data: {
+                target: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                    encodingHash: string;
+                };
+                background: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                    encodingHash: string;
+                    domain: string;
+                }[];
+                preservation: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                    encodingHash: string;
+                } | null;
+            };
+            selection: {
+                count: number;
+                span: "prompt" | "reply_prediction" | "reply_start";
+                backgroundStatistic: "max_domains" | "mean_domains";
+                maximumBackgroundTargetRatio: number;
+                gradientExamples: number;
+                explicitCoordinates: {
+                    layer: number;
+                    neuron: number;
+                }[] | null;
+            };
+            training: {
+                learningRate: number;
+                maxSteps: number;
+                gradientAccumulationSteps: number;
+                maxSequenceLength: number;
+                preservationWeight: number;
+                preservationExamplesPerStep: number;
+                seed: number;
+                maxDurationSeconds: number;
+                maxCheckpointBytes: number;
+                maximumForwardTokenWork: number;
+            };
+            parentArtifact: null;
+        };
+        artifact: {
+            id: string;
+            contentHash: string;
+            manifest: {
+                schemaVersion: "openpond.neuronTrainingArtifact.v1";
+                method: "selective_neuron_training";
+                algorithm: {
+                    implementation: "openpond_qwen3_selective_columns_v1";
+                    upstream: "changjonathanc/neuron-tuning";
+                    revision: "8a55f3159f735eb0823d7a894f67f632bf568bb3";
+                    license: "Apache-2.0";
+                    hook: "mlp.down_proj";
+                    operation: "output_plus_selected_input_times_delta_v1";
+                    parameterization: "column_gain_rms_direction_v1";
+                    activityQuantile: 0.9;
+                    backgroundFloor: 0.000001;
+                    gradientSubsetSeed: 0;
+                    optimizer: "Adam";
+                    betas: [0.9, 0.999];
+                    epsilon: 1e-8;
+                    weightDecay: 0;
+                    gradientClipNorm: 1;
+                    batchSize: 1;
+                    parameterDtype: "float32";
+                    resume: "unsupported";
+                };
+                pins: {
+                    baseModel: {
+                        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[];
+                    };
+                    inputHash: string;
+                    data: {
+                        target: {
+                            batch: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                            examplesSha256: string;
+                            encodingHash: string;
+                        };
+                        background: {
+                            batch: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                            examplesSha256: string;
+                            encodingHash: string;
+                            domain: string;
+                        }[];
+                        preservation: {
+                            batch: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                            examplesSha256: string;
+                            encodingHash: string;
+                        } | null;
+                    };
+                    dataHash: string;
+                    selectionConfigHash: string;
+                    trainingConfigHash: string;
+                    runtimeHash: string;
+                    parentArtifactHash: null;
+                };
+                selection: {
+                    schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
+                    modelHash: string;
+                    dataHash: string;
+                    selectionConfigHash: string;
+                    preparedRowsHash: string;
+                    source: "automatic" | "explicit";
+                    targetExampleIds: string[];
+                    eligibleCount: number;
+                    entries: {
+                        layer: number;
+                        neuron: number;
+                        targetMeanAbsolute: number;
+                        backgroundMeanAbsolute: number;
+                        backgroundTargetRatio: number;
+                        gradientNorm: number;
+                        score: number;
+                        targetActivityThreshold: number;
+                        backgroundByDomain: {
+                            domainIndex: number;
+                            meanAbsolute: number;
+                        }[];
+                    }[];
+                    contentHash: string;
+                };
+                payload: {
+                    path: "patch.safetensors";
+                    sha256: string;
+                    sizeBytes: number;
+                    tensors: {
+                        name: string;
+                        dtype: "F32" | "I64";
+                        shape: number[];
+                    }[];
+                };
+                contentHash: string;
+            };
+            files: {
+                path: "manifest.json" | "patch.safetensors";
+                artifactId: string;
+                sha256: string;
+                sizeBytes: number;
+            }[];
+        };
+        contentHash: string;
+    };
+    contentHash: string;
+}>;
+export declare function createWeightModelClient(request: (path: string, init?: RequestInit) => Promise<unknown>): {
+    saveAlphaEditResultModel(raw: AlphaEditResultSaveRequest): Promise<{
+        teamId: string;
+        actorId: string;
+        operationId: string;
+        requestHash: string;
+        model: {
+            id: string;
+            teamId: string;
+            portableProjectId: string;
+            name: string;
+            objective: string | null;
+            defaultBaseModel: {
+                schemaVersion: "openpond.baseModelPreference.v1";
+                modelId: string;
+                revision: string | null;
+                tokenizerRevision: string | null;
+                chatTemplateHash: string | null;
+                modelAssetId: string | null;
+                source: "builtin" | "local" | "managed";
+            } | null;
+            defaultDestinationId: string | null;
+            trainingSetup: {
+                tasksetRef: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null;
+                evaluationTasksetRef?: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null | undefined;
+                profileSource?: {
+                    profileProjectId: string;
+                    sourceRevision: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                } | null | undefined;
+                profileEvaluation?: {
+                    profileProjectId: string;
+                    sourceRevision: string;
+                    catalogHash: string;
+                    definitionId: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    tasksetRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                } | null | undefined;
+                rewardBindingRef?: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null | undefined;
+                tasksetRelease: {
+                    id: string;
+                    contentHash: string;
+                } | null;
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                } | null;
+                baseModel: {
+                    schemaVersion: "openpond.baseModelPreference.v1";
+                    modelId: string;
+                    revision: string | null;
+                    tokenizerRevision: string | null;
+                    chatTemplateHash: string | null;
+                    modelAssetId: string | null;
+                    source: "builtin" | "local" | "managed";
+                } | null;
+                method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft" | null;
+                destinationId: string | null;
+                managedRolloutPlacement: "local" | "remote";
+                managedGpuPlacementObjective: "balanced" | "economical" | "fast";
+                managedGpuSelection?: {
+                    mode: "automatic";
+                    objective: "balanced" | "economical" | "fast";
+                    gpuCount?: 1 | 2 | undefined;
+                } | {
+                    mode: "manual";
+                    availabilityId: string;
+                    gpuType: string;
+                    gpuCount?: 1 | 2 | undefined;
+                } | undefined;
+                continuationAdapterMode?: "residual_append" | "sequential_merge" | "shared" | undefined;
+                managedGpuRequirement: "any" | "h100_hbm3";
+                runPreset: "custom" | "small" | "small_experiment" | "standard" | null;
+                recipe: {
+                    [x: string]: unknown;
+                    schemaVersion: string;
+                    method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft";
+                    parameterization: "full" | "lora";
+                } | null;
+                preferredMaximumSpendUsd: number | null;
+                preferredRetentionDays: number | null;
+            };
+            sourceRevision: number;
+            sourceUpdatedAt: string;
+            revision: number;
+            etag: string;
+            createdAt: string;
+            updatedAt: string;
+        };
+        schemaVersion: "openpond.alphaEditResultSaveReceipt.v1";
+        version: {
+            teamId: string;
+            ownerUserId: string;
+            modelProjectId: string;
+            portableProjectId: string;
+            baseModel: {
+                schemaVersion: "openpond.baseModelPreference.v1";
+                modelId: string;
+                revision: string | null;
+                tokenizerRevision: string | null;
+                chatTemplateHash: string | null;
+                modelAssetId: string | null;
+                source: "builtin" | "local" | "managed";
+            };
+            source: {
+                executionId: string;
+                inputHash: string;
+                runtimeHash: string;
+                resultHash: string;
+            };
+            createdAt: string;
+            schemaVersion: "openpond.alphaEditModelVersion.v1";
+            request: {
+                schemaVersion: "openpond.alphaEditTrainingRequest.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[];
+                };
+                data: {
+                    edits: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                    };
+                    preservation: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                    };
+                };
+                config: {
+                    schemaVersion: "openpond.alphaEditConfig.v1";
+                    implementation: "openpond_qwen_alphaedit_v1";
+                    sourceRevision: "b84624f44dfe8fc6cd9e41df916c44124a0c46dc";
+                    rewriteModule: "mlp.down_proj.weight";
+                    factToken: "subject_last";
+                    layers: number[];
+                    lossLayer: number;
+                    contextTemplateGroups: string[][];
+                    nullspaceThreshold: number;
+                    l2: number;
+                    covariance: "non_padding_uncentered_second_moment_fp32_v1";
+                    projector: "covariance_svd_below_absolute_threshold_v1";
+                    sequentialState: "post_edit_group_mean_keys_outer_product_sum_v1";
+                    targetTokenization: "leading_space_no_special_tokens_v1";
+                };
+                training: {
+                    maxSteps: number;
+                    learningRate: number;
+                    klFactor: number;
+                    latentWeightDecay: number;
+                    clampNormFactor: number;
+                    maxSequenceLength: number;
+                    maxDurationSeconds: number;
+                    maxForwardTokenWork: number;
+                    maxCheckpointBytes: number;
+                    seed: number;
+                };
+                parentArtifact: {
+                    id: string;
+                    contentHash: string;
+                } | null;
+            };
+            artifact: {
+                id: string;
+                contentHash: string;
+                manifest: {
+                    schemaVersion: "openpond.alphaEditArtifact.v1";
+                    method: "alphaedit";
+                    config: {
+                        schemaVersion: "openpond.alphaEditConfig.v1";
+                        implementation: "openpond_qwen_alphaedit_v1";
+                        sourceRevision: "b84624f44dfe8fc6cd9e41df916c44124a0c46dc";
+                        rewriteModule: "mlp.down_proj.weight";
+                        factToken: "subject_last";
+                        layers: number[];
+                        lossLayer: number;
+                        contextTemplateGroups: string[][];
+                        nullspaceThreshold: number;
+                        l2: number;
+                        covariance: "non_padding_uncentered_second_moment_fp32_v1";
+                        projector: "covariance_svd_below_absolute_threshold_v1";
+                        sequentialState: "post_edit_group_mean_keys_outer_product_sum_v1";
+                        targetTokenization: "leading_space_no_special_tokens_v1";
+                    };
+                    pins: {
+                        baseModel: {
+                            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[];
+                        };
+                        configHash: string;
+                        recipeHash: string;
+                        dataHash: string;
+                        data: {
+                            edits: {
+                                batch: {
+                                    id: string;
+                                    contentHash: string;
+                                    revision: number;
+                                };
+                                examplesSha256: string;
+                            };
+                            preservation: {
+                                batch: {
+                                    id: string;
+                                    contentHash: string;
+                                    revision: number;
+                                };
+                                examplesSha256: string;
+                            };
+                        };
+                        runtimeHash: string;
+                        parentArtifactHash: string | null;
+                        preservationModelHash: string;
+                    };
+                    representation: "exact_replacement_bf16_down_proj_matrices_v1";
+                    payloads: {
+                        patch: {
+                            sha256: string;
+                            sizeBytes: number;
+                            tensors: {
+                                name: string;
+                                shape: number[];
+                                dtype: "BF16" | "F32";
+                            }[];
+                            path: "patch.safetensors";
+                        };
+                        state: {
+                            sha256: string;
+                            sizeBytes: number;
+                            tensors: {
+                                name: string;
+                                shape: number[];
+                                dtype: "BF16" | "F32";
+                            }[];
+                            path: string;
+                        }[];
+                    };
+                    contentHash: string;
+                };
+                files: {
+                    path: string;
+                    artifactId: string;
+                    sha256: string;
+                    sizeBytes: number;
+                }[];
+            };
+            contentHash: string;
+        };
+        contentHash: string;
+    }>;
+    saveNeuronTrainingResultModel(raw: NeuronTrainingResultSaveRequest): Promise<{
+        teamId: string;
+        actorId: string;
+        operationId: string;
+        requestHash: string;
+        model: {
+            id: string;
+            teamId: string;
+            portableProjectId: string;
+            name: string;
+            objective: string | null;
+            defaultBaseModel: {
+                schemaVersion: "openpond.baseModelPreference.v1";
+                modelId: string;
+                revision: string | null;
+                tokenizerRevision: string | null;
+                chatTemplateHash: string | null;
+                modelAssetId: string | null;
+                source: "builtin" | "local" | "managed";
+            } | null;
+            defaultDestinationId: string | null;
+            trainingSetup: {
+                tasksetRef: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null;
+                evaluationTasksetRef?: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null | undefined;
+                profileSource?: {
+                    profileProjectId: string;
+                    sourceRevision: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                } | null | undefined;
+                profileEvaluation?: {
+                    profileProjectId: string;
+                    sourceRevision: string;
+                    catalogHash: string;
+                    definitionId: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    tasksetRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                } | null | undefined;
+                rewardBindingRef?: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null | undefined;
+                tasksetRelease: {
+                    id: string;
+                    contentHash: string;
+                } | null;
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                } | null;
+                baseModel: {
+                    schemaVersion: "openpond.baseModelPreference.v1";
+                    modelId: string;
+                    revision: string | null;
+                    tokenizerRevision: string | null;
+                    chatTemplateHash: string | null;
+                    modelAssetId: string | null;
+                    source: "builtin" | "local" | "managed";
+                } | null;
+                method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft" | null;
+                destinationId: string | null;
+                managedRolloutPlacement: "local" | "remote";
+                managedGpuPlacementObjective: "balanced" | "economical" | "fast";
+                managedGpuSelection?: {
+                    mode: "automatic";
+                    objective: "balanced" | "economical" | "fast";
+                    gpuCount?: 1 | 2 | undefined;
+                } | {
+                    mode: "manual";
+                    availabilityId: string;
+                    gpuType: string;
+                    gpuCount?: 1 | 2 | undefined;
+                } | undefined;
+                continuationAdapterMode?: "residual_append" | "sequential_merge" | "shared" | undefined;
+                managedGpuRequirement: "any" | "h100_hbm3";
+                runPreset: "custom" | "small" | "small_experiment" | "standard" | null;
+                recipe: {
+                    [x: string]: unknown;
+                    schemaVersion: string;
+                    method: "dpo" | "grpo" | "opd" | "opsd" | "ppo" | "sdft" | "sdpo" | "sft";
+                    parameterization: "full" | "lora";
+                } | null;
+                preferredMaximumSpendUsd: number | null;
+                preferredRetentionDays: number | null;
+            };
+            sourceRevision: number;
+            sourceUpdatedAt: string;
+            revision: number;
+            etag: string;
+            createdAt: string;
+            updatedAt: string;
+        };
+        schemaVersion: "openpond.neuronTrainingResultSaveReceipt.v1";
+        version: {
+            teamId: string;
+            ownerUserId: string;
+            modelProjectId: string;
+            portableProjectId: string;
+            baseModel: {
+                schemaVersion: "openpond.baseModelPreference.v1";
+                modelId: string;
+                revision: string | null;
+                tokenizerRevision: string | null;
+                chatTemplateHash: string | null;
+                modelAssetId: string | null;
+                source: "builtin" | "local" | "managed";
+            };
+            source: {
+                executionId: string;
+                inputHash: string;
+                runtimeHash: string;
+                resultHash: string;
+            };
+            createdAt: string;
+            schemaVersion: "openpond.neuronTrainingModelVersion.v1";
+            request: {
+                schemaVersion: "openpond.selectiveNeuronTrainingRequest.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[];
+                };
+                data: {
+                    target: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                        encodingHash: string;
+                    };
+                    background: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                        encodingHash: string;
+                        domain: string;
+                    }[];
+                    preservation: {
+                        batch: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        examplesSha256: string;
+                        encodingHash: string;
+                    } | null;
+                };
+                selection: {
+                    count: number;
+                    span: "prompt" | "reply_prediction" | "reply_start";
+                    backgroundStatistic: "max_domains" | "mean_domains";
+                    maximumBackgroundTargetRatio: number;
+                    gradientExamples: number;
+                    explicitCoordinates: {
+                        layer: number;
+                        neuron: number;
+                    }[] | null;
+                };
+                training: {
+                    learningRate: number;
+                    maxSteps: number;
+                    gradientAccumulationSteps: number;
+                    maxSequenceLength: number;
+                    preservationWeight: number;
+                    preservationExamplesPerStep: number;
+                    seed: number;
+                    maxDurationSeconds: number;
+                    maxCheckpointBytes: number;
+                    maximumForwardTokenWork: number;
+                };
+                parentArtifact: null;
+            };
+            artifact: {
+                id: string;
+                contentHash: string;
+                manifest: {
+                    schemaVersion: "openpond.neuronTrainingArtifact.v1";
+                    method: "selective_neuron_training";
+                    algorithm: {
+                        implementation: "openpond_qwen3_selective_columns_v1";
+                        upstream: "changjonathanc/neuron-tuning";
+                        revision: "8a55f3159f735eb0823d7a894f67f632bf568bb3";
+                        license: "Apache-2.0";
+                        hook: "mlp.down_proj";
+                        operation: "output_plus_selected_input_times_delta_v1";
+                        parameterization: "column_gain_rms_direction_v1";
+                        activityQuantile: 0.9;
+                        backgroundFloor: 0.000001;
+                        gradientSubsetSeed: 0;
+                        optimizer: "Adam";
+                        betas: [0.9, 0.999];
+                        epsilon: 1e-8;
+                        weightDecay: 0;
+                        gradientClipNorm: 1;
+                        batchSize: 1;
+                        parameterDtype: "float32";
+                        resume: "unsupported";
+                    };
+                    pins: {
+                        baseModel: {
+                            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[];
+                        };
+                        inputHash: string;
+                        data: {
+                            target: {
+                                batch: {
+                                    id: string;
+                                    contentHash: string;
+                                    revision: number;
+                                };
+                                examplesSha256: string;
+                                encodingHash: string;
+                            };
+                            background: {
+                                batch: {
+                                    id: string;
+                                    contentHash: string;
+                                    revision: number;
+                                };
+                                examplesSha256: string;
+                                encodingHash: string;
+                                domain: string;
+                            }[];
+                            preservation: {
+                                batch: {
+                                    id: string;
+                                    contentHash: string;
+                                    revision: number;
+                                };
+                                examplesSha256: string;
+                                encodingHash: string;
+                            } | null;
+                        };
+                        dataHash: string;
+                        selectionConfigHash: string;
+                        trainingConfigHash: string;
+                        runtimeHash: string;
+                        parentArtifactHash: null;
+                    };
+                    selection: {
+                        schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
+                        modelHash: string;
+                        dataHash: string;
+                        selectionConfigHash: string;
+                        preparedRowsHash: string;
+                        source: "automatic" | "explicit";
+                        targetExampleIds: string[];
+                        eligibleCount: number;
+                        entries: {
+                            layer: number;
+                            neuron: number;
+                            targetMeanAbsolute: number;
+                            backgroundMeanAbsolute: number;
+                            backgroundTargetRatio: number;
+                            gradientNorm: number;
+                            score: number;
+                            targetActivityThreshold: number;
+                            backgroundByDomain: {
+                                domainIndex: number;
+                                meanAbsolute: number;
+                            }[];
+                        }[];
+                        contentHash: string;
+                    };
+                    payload: {
+                        path: "patch.safetensors";
+                        sha256: string;
+                        sizeBytes: number;
+                        tensors: {
+                            name: string;
+                            dtype: "F32" | "I64";
+                            shape: number[];
+                        }[];
+                    };
+                    contentHash: string;
+                };
+                files: {
+                    path: "manifest.json" | "patch.safetensors";
+                    artifactId: string;
+                    sha256: string;
+                    sizeBytes: number;
+                }[];
+            };
+            contentHash: string;
+        };
+        contentHash: string;
+    }>;
+};
+export {};
+//# sourceMappingURL=weight-model-versions.d.ts.map