openpond-sdk 0.12.13 → 0.12.15

package/dist/types/packages/sdk/src/modification-recordings.d.ts

@@ -0,0 +1,1303 @@
+import { z } from "zod";
+export declare const MODIFICATION_RECORDING_MAX_BYTES = 8388608;
+export declare const ModificationRecordingRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.modificationRecordingRequest.v1">;
+    teamId: z.ZodString;
+    operationId: z.ZodString;
+    name: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    method: z.ZodEnum<{
+        inspect_activations: "inspect_activations";
+        neuron_steering: "neuron_steering";
+    }>;
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.activationReferenceRequest.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>;
+        startingProfile: z.ZodOptional<z.ZodObject<{
+            modelProjectId: z.ZodString;
+            versionHash: z.ZodString;
+            publication: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            profileHash: z.ZodString;
+            variantId: z.ZodString;
+        }, z.core.$strict>>;
+        prompts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            tokenIds: z.ZodArray<z.ZodNumber>;
+            attentionMask: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        }, z.core.$strict>>;
+        variants: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            profile: z.ZodNullable<z.ZodLazy<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronSteeringProfile.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>;
+                hook: z.ZodLiteral<"mlp.down_proj.input">;
+                operation: z.ZodLiteral<"add">;
+                normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+                    statistic: z.ZodLiteral<"midpoint_median_fp32">;
+                    sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"fixed_residual_reference">;
+                    calibration: z.ZodObject<{
+                        id: z.ZodString;
+                        revision: z.ZodNumber;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>], "mode">;
+                tokenScope: z.ZodObject<{
+                    phase: z.ZodEnum<{
+                        decode_only: "decode_only";
+                        prompt_and_decode: "prompt_and_decode";
+                        prompt_only: "prompt_only";
+                    }>;
+                    positions: z.ZodEnum<{
+                        after_position_zero: "after_position_zero";
+                        all_non_padding: "all_non_padding";
+                    }>;
+                }, z.core.$strict>;
+                entries: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    neuron: z.ZodNumber;
+                    dose: z.ZodNumber;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        capture: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            neurons: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+        maxNewTokens: z.ZodNumber;
+        eosTokenIds: z.ZodArray<z.ZodNumber>;
+        maximumCapturedValues: z.ZodNumber;
+        maximumForwardTokenWork: z.ZodNumber;
+        maximumDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    result: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.activationReferenceResult.v1">;
+        requestHash: z.ZodString;
+        modelHash: z.ZodString;
+        runtime: z.ZodObject<{
+            implementation: z.ZodLiteral<"torch_dense_serial_reference_v1">;
+            implementationHash: z.ZodString;
+            torchVersion: z.ZodString;
+            device: z.ZodString;
+        }, z.core.$strict>;
+        outcomes: z.ZodArray<z.ZodObject<{
+            promptId: z.ZodString;
+            variantId: z.ZodString;
+            profileHash: z.ZodNullable<z.ZodString>;
+            generatedTokenIds: z.ZodArray<z.ZodNumber>;
+            forwardTokenWork: z.ZodNumber;
+            calibration: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                median: z.ZodNumber;
+                sampleCount: z.ZodNumber;
+                columnNorms: z.ZodArray<z.ZodObject<{
+                    neuron: z.ZodNumber;
+                    norm: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            durationMs: z.ZodNumber;
+            captureCount: z.ZodNumber;
+        }, z.core.$strict>>;
+        captures: z.ZodArray<z.ZodObject<{
+            promptId: z.ZodString;
+            variantId: z.ZodString;
+            layer: z.ZodNumber;
+            neuron: z.ZodNumber;
+            tokenIndex: z.ZodNumber;
+            tokenId: z.ZodNumber;
+            before: z.ZodNumber;
+            after: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ModificationRecordingRequest = z.infer<typeof ModificationRecordingRequestSchema>;
+export declare const ModificationRecordingContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.modificationRecording.v1">;
+    id: z.ZodString;
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    operationId: z.ZodString;
+    commandHash: z.ZodString;
+    name: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    method: z.ZodEnum<{
+        inspect_activations: "inspect_activations";
+        neuron_steering: "neuron_steering";
+    }>;
+    accountScopeHash: z.ZodString;
+    custody: z.ZodLiteral<"local">;
+    provenance: z.ZodLiteral<"external_observation">;
+    measurementAttestation: z.ZodLiteral<"unattested">;
+    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>;
+    inputHash: z.ZodString;
+    resultHash: z.ZodString;
+    artifact: z.ZodObject<{
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+    }, z.core.$strict>;
+    counts: z.ZodObject<{
+        prompts: z.ZodNumber;
+        variants: z.ZodNumber;
+        outcomes: z.ZodNumber;
+        captures: z.ZodNumber;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const ModificationRecordingSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.modificationRecording.v1">;
+    id: z.ZodString;
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    operationId: z.ZodString;
+    commandHash: z.ZodString;
+    name: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    method: z.ZodEnum<{
+        inspect_activations: "inspect_activations";
+        neuron_steering: "neuron_steering";
+    }>;
+    accountScopeHash: z.ZodString;
+    custody: z.ZodLiteral<"local">;
+    provenance: z.ZodLiteral<"external_observation">;
+    measurementAttestation: z.ZodLiteral<"unattested">;
+    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>;
+    inputHash: z.ZodString;
+    resultHash: z.ZodString;
+    artifact: z.ZodObject<{
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+    }, z.core.$strict>;
+    counts: z.ZodObject<{
+        prompts: z.ZodNumber;
+        variants: z.ZodNumber;
+        outcomes: z.ZodNumber;
+        captures: z.ZodNumber;
+    }, z.core.$strict>;
+    createdAt: z.ZodISODateTime;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type ModificationRecording = z.infer<typeof ModificationRecordingSchema>;
+export declare const ModificationRecordingDocumentSchema: z.ZodObject<{
+    request: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.activationReferenceRequest.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>;
+        startingProfile: z.ZodOptional<z.ZodObject<{
+            modelProjectId: z.ZodString;
+            versionHash: z.ZodString;
+            publication: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            profileHash: z.ZodString;
+            variantId: z.ZodString;
+        }, z.core.$strict>>;
+        prompts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            tokenIds: z.ZodArray<z.ZodNumber>;
+            attentionMask: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        }, z.core.$strict>>;
+        variants: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            profile: z.ZodNullable<z.ZodLazy<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.neuronSteeringProfile.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>;
+                hook: z.ZodLiteral<"mlp.down_proj.input">;
+                operation: z.ZodLiteral<"add">;
+                normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+                    statistic: z.ZodLiteral<"midpoint_median_fp32">;
+                    sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+                }, z.core.$strict>, z.ZodObject<{
+                    mode: z.ZodLiteral<"fixed_residual_reference">;
+                    calibration: z.ZodObject<{
+                        id: z.ZodString;
+                        revision: z.ZodNumber;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>], "mode">;
+                tokenScope: z.ZodObject<{
+                    phase: z.ZodEnum<{
+                        decode_only: "decode_only";
+                        prompt_and_decode: "prompt_and_decode";
+                        prompt_only: "prompt_only";
+                    }>;
+                    positions: z.ZodEnum<{
+                        after_position_zero: "after_position_zero";
+                        all_non_padding: "all_non_padding";
+                    }>;
+                }, z.core.$strict>;
+                entries: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    neuron: z.ZodNumber;
+                    dose: z.ZodNumber;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        capture: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            neurons: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+        maxNewTokens: z.ZodNumber;
+        eosTokenIds: z.ZodArray<z.ZodNumber>;
+        maximumCapturedValues: z.ZodNumber;
+        maximumForwardTokenWork: z.ZodNumber;
+        maximumDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    result: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.activationReferenceResult.v1">;
+        requestHash: z.ZodString;
+        modelHash: z.ZodString;
+        runtime: z.ZodObject<{
+            implementation: z.ZodLiteral<"torch_dense_serial_reference_v1">;
+            implementationHash: z.ZodString;
+            torchVersion: z.ZodString;
+            device: z.ZodString;
+        }, z.core.$strict>;
+        outcomes: z.ZodArray<z.ZodObject<{
+            promptId: z.ZodString;
+            variantId: z.ZodString;
+            profileHash: z.ZodNullable<z.ZodString>;
+            generatedTokenIds: z.ZodArray<z.ZodNumber>;
+            forwardTokenWork: z.ZodNumber;
+            calibration: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                median: z.ZodNumber;
+                sampleCount: z.ZodNumber;
+                columnNorms: z.ZodArray<z.ZodObject<{
+                    neuron: z.ZodNumber;
+                    norm: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            durationMs: z.ZodNumber;
+            captureCount: z.ZodNumber;
+        }, z.core.$strict>>;
+        captures: z.ZodArray<z.ZodObject<{
+            promptId: z.ZodString;
+            variantId: z.ZodString;
+            layer: z.ZodNumber;
+            neuron: z.ZodNumber;
+            tokenIndex: z.ZodNumber;
+            tokenId: z.ZodNumber;
+            before: z.ZodNumber;
+            after: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ModificationRecordingReadSchema: z.ZodObject<{
+    recording: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.modificationRecording.v1">;
+        id: z.ZodString;
+        teamId: z.ZodString;
+        actorId: z.ZodString;
+        operationId: z.ZodString;
+        commandHash: z.ZodString;
+        name: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        method: z.ZodEnum<{
+            inspect_activations: "inspect_activations";
+            neuron_steering: "neuron_steering";
+        }>;
+        accountScopeHash: z.ZodString;
+        custody: z.ZodLiteral<"local">;
+        provenance: z.ZodLiteral<"external_observation">;
+        measurementAttestation: z.ZodLiteral<"unattested">;
+        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>;
+        inputHash: z.ZodString;
+        resultHash: z.ZodString;
+        artifact: z.ZodObject<{
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>;
+        counts: z.ZodObject<{
+            prompts: z.ZodNumber;
+            variants: z.ZodNumber;
+            outcomes: z.ZodNumber;
+            captures: z.ZodNumber;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    document: z.ZodObject<{
+        request: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.activationReferenceRequest.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>;
+            startingProfile: z.ZodOptional<z.ZodObject<{
+                modelProjectId: z.ZodString;
+                versionHash: z.ZodString;
+                publication: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                profileHash: z.ZodString;
+                variantId: z.ZodString;
+            }, z.core.$strict>>;
+            prompts: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                tokenIds: z.ZodArray<z.ZodNumber>;
+                attentionMask: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+            }, z.core.$strict>>;
+            variants: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                profile: z.ZodNullable<z.ZodLazy<z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.neuronSteeringProfile.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>;
+                    hook: z.ZodLiteral<"mlp.down_proj.input">;
+                    operation: z.ZodLiteral<"add">;
+                    normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+                        statistic: z.ZodLiteral<"midpoint_median_fp32">;
+                        sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        mode: z.ZodLiteral<"fixed_residual_reference">;
+                        calibration: z.ZodObject<{
+                            id: z.ZodString;
+                            revision: z.ZodNumber;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>], "mode">;
+                    tokenScope: z.ZodObject<{
+                        phase: z.ZodEnum<{
+                            decode_only: "decode_only";
+                            prompt_and_decode: "prompt_and_decode";
+                            prompt_only: "prompt_only";
+                        }>;
+                        positions: z.ZodEnum<{
+                            after_position_zero: "after_position_zero";
+                            all_non_padding: "all_non_padding";
+                        }>;
+                    }, z.core.$strict>;
+                    entries: z.ZodArray<z.ZodObject<{
+                        layer: z.ZodNumber;
+                        neuron: z.ZodNumber;
+                        dose: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+            capture: z.ZodArray<z.ZodObject<{
+                layer: z.ZodNumber;
+                neurons: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strict>>;
+            maxNewTokens: z.ZodNumber;
+            eosTokenIds: z.ZodArray<z.ZodNumber>;
+            maximumCapturedValues: z.ZodNumber;
+            maximumForwardTokenWork: z.ZodNumber;
+            maximumDurationSeconds: z.ZodNumber;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.activationReferenceResult.v1">;
+            requestHash: z.ZodString;
+            modelHash: z.ZodString;
+            runtime: z.ZodObject<{
+                implementation: z.ZodLiteral<"torch_dense_serial_reference_v1">;
+                implementationHash: z.ZodString;
+                torchVersion: z.ZodString;
+                device: z.ZodString;
+            }, z.core.$strict>;
+            outcomes: z.ZodArray<z.ZodObject<{
+                promptId: z.ZodString;
+                variantId: z.ZodString;
+                profileHash: z.ZodNullable<z.ZodString>;
+                generatedTokenIds: z.ZodArray<z.ZodNumber>;
+                forwardTokenWork: z.ZodNumber;
+                calibration: z.ZodArray<z.ZodObject<{
+                    layer: z.ZodNumber;
+                    median: z.ZodNumber;
+                    sampleCount: z.ZodNumber;
+                    columnNorms: z.ZodArray<z.ZodObject<{
+                        neuron: z.ZodNumber;
+                        norm: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                durationMs: z.ZodNumber;
+                captureCount: z.ZodNumber;
+            }, z.core.$strict>>;
+            captures: z.ZodArray<z.ZodObject<{
+                promptId: z.ZodString;
+                variantId: z.ZodString;
+                layer: z.ZodNumber;
+                neuron: z.ZodNumber;
+                tokenIndex: z.ZodNumber;
+                tokenId: z.ZodNumber;
+                before: z.ZodNumber;
+                after: z.ZodNumber;
+            }, z.core.$strict>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ModificationRecordingReadQuerySchema: z.ZodObject<{
+    teamId: z.ZodString;
+}, z.core.$strict>;
+export declare const ModificationRecordingListQuerySchema: z.ZodObject<{
+    teamId: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type ModificationRecordingListQuery = z.input<typeof ModificationRecordingListQuerySchema>;
+export declare const ModificationRecordingPageSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    actorId: z.ZodString;
+    accountScopeHash: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.modificationRecording.v1">;
+        id: z.ZodString;
+        teamId: z.ZodString;
+        actorId: z.ZodString;
+        operationId: z.ZodString;
+        commandHash: z.ZodString;
+        name: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        method: z.ZodEnum<{
+            inspect_activations: "inspect_activations";
+            neuron_steering: "neuron_steering";
+        }>;
+        accountScopeHash: z.ZodString;
+        custody: z.ZodLiteral<"local">;
+        provenance: z.ZodLiteral<"external_observation">;
+        measurementAttestation: z.ZodLiteral<"unattested">;
+        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>;
+        inputHash: z.ZodString;
+        resultHash: z.ZodString;
+        artifact: z.ZodObject<{
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>;
+        counts: z.ZodObject<{
+            prompts: z.ZodNumber;
+            variants: z.ZodNumber;
+            outcomes: z.ZodNumber;
+            captures: z.ZodNumber;
+        }, z.core.$strict>;
+        createdAt: z.ZodISODateTime;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare function verifyModificationRecordingRequest(raw: unknown): Promise<{
+    schemaVersion: "openpond.modificationRecordingRequest.v1";
+    teamId: string;
+    operationId: string;
+    name: string;
+    projectId: string | null;
+    method: "inspect_activations" | "neuron_steering";
+    request: {
+        schemaVersion: "openpond.activationReferenceRequest.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[];
+        };
+        startingProfile?: {
+            modelProjectId: string;
+            versionHash: string;
+            publication: {
+                id: string;
+                revision: number;
+                contentHash: string;
+            };
+            profileHash: string;
+            variantId: string;
+        } | undefined;
+        prompts: {
+            id: string;
+            tokenIds: number[];
+            attentionMask: (0 | 1)[];
+        }[];
+        variants: {
+            id: string;
+            profile: {
+                schemaVersion: "openpond.neuronSteeringProfile.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[];
+                };
+                hook: "mlp.down_proj.input";
+                operation: "add";
+                normalization: {
+                    mode: "baseline_prompt_residual_median";
+                    statistic: "midpoint_median_fp32";
+                    sample: "non_padding_prompt_after_position_zero";
+                } | {
+                    mode: "fixed_residual_reference";
+                    calibration: {
+                        id: string;
+                        revision: number;
+                        contentHash: string;
+                    };
+                };
+                tokenScope: {
+                    phase: "decode_only" | "prompt_and_decode" | "prompt_only";
+                    positions: "after_position_zero" | "all_non_padding";
+                };
+                entries: {
+                    layer: number;
+                    neuron: number;
+                    dose: number;
+                }[];
+                contentHash: string;
+            } | null;
+        }[];
+        capture: {
+            layer: number;
+            neurons: number[];
+        }[];
+        maxNewTokens: number;
+        eosTokenIds: number[];
+        maximumCapturedValues: number;
+        maximumForwardTokenWork: number;
+        maximumDurationSeconds: number;
+    };
+    result: {
+        schemaVersion: "openpond.activationReferenceResult.v1";
+        requestHash: string;
+        modelHash: string;
+        runtime: {
+            implementation: "torch_dense_serial_reference_v1";
+            implementationHash: string;
+            torchVersion: string;
+            device: string;
+        };
+        outcomes: {
+            promptId: string;
+            variantId: string;
+            profileHash: string | null;
+            generatedTokenIds: number[];
+            forwardTokenWork: number;
+            calibration: {
+                layer: number;
+                median: number;
+                sampleCount: number;
+                columnNorms: {
+                    neuron: number;
+                    norm: number;
+                }[];
+            }[];
+            durationMs: number;
+            captureCount: number;
+        }[];
+        captures: {
+            promptId: string;
+            variantId: string;
+            layer: number;
+            neuron: number;
+            tokenIndex: number;
+            tokenId: number;
+            before: number;
+            after: number;
+        }[];
+        contentHash: string;
+    };
+}>;
+export declare function verifyModificationRecording(raw: unknown, teamId?: string, actorId?: string): Promise<{
+    schemaVersion: "openpond.modificationRecording.v1";
+    id: string;
+    teamId: string;
+    actorId: string;
+    operationId: string;
+    commandHash: string;
+    name: string;
+    projectId: string | null;
+    method: "inspect_activations" | "neuron_steering";
+    accountScopeHash: string;
+    custody: "local";
+    provenance: "external_observation";
+    measurementAttestation: "unattested";
+    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[];
+    };
+    inputHash: string;
+    resultHash: string;
+    artifact: {
+        contentHash: string;
+        sizeBytes: number;
+    };
+    counts: {
+        prompts: number;
+        variants: number;
+        outcomes: number;
+        captures: number;
+    };
+    createdAt: string;
+    contentHash: string;
+}>;
+export declare function verifyModificationRecordingRead(raw: unknown, teamId?: string, actorId?: string): Promise<{
+    document: {
+        request: {
+            schemaVersion: "openpond.activationReferenceRequest.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[];
+            };
+            startingProfile?: {
+                modelProjectId: string;
+                versionHash: string;
+                publication: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                profileHash: string;
+                variantId: string;
+            } | undefined;
+            prompts: {
+                id: string;
+                tokenIds: number[];
+                attentionMask: (0 | 1)[];
+            }[];
+            variants: {
+                id: string;
+                profile: {
+                    schemaVersion: "openpond.neuronSteeringProfile.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[];
+                    };
+                    hook: "mlp.down_proj.input";
+                    operation: "add";
+                    normalization: {
+                        mode: "baseline_prompt_residual_median";
+                        statistic: "midpoint_median_fp32";
+                        sample: "non_padding_prompt_after_position_zero";
+                    } | {
+                        mode: "fixed_residual_reference";
+                        calibration: {
+                            id: string;
+                            revision: number;
+                            contentHash: string;
+                        };
+                    };
+                    tokenScope: {
+                        phase: "decode_only" | "prompt_and_decode" | "prompt_only";
+                        positions: "after_position_zero" | "all_non_padding";
+                    };
+                    entries: {
+                        layer: number;
+                        neuron: number;
+                        dose: number;
+                    }[];
+                    contentHash: string;
+                } | null;
+            }[];
+            capture: {
+                layer: number;
+                neurons: number[];
+            }[];
+            maxNewTokens: number;
+            eosTokenIds: number[];
+            maximumCapturedValues: number;
+            maximumForwardTokenWork: number;
+            maximumDurationSeconds: number;
+        };
+        result: {
+            schemaVersion: "openpond.activationReferenceResult.v1";
+            requestHash: string;
+            modelHash: string;
+            runtime: {
+                implementation: "torch_dense_serial_reference_v1";
+                implementationHash: string;
+                torchVersion: string;
+                device: string;
+            };
+            outcomes: {
+                promptId: string;
+                variantId: string;
+                profileHash: string | null;
+                generatedTokenIds: number[];
+                forwardTokenWork: number;
+                calibration: {
+                    layer: number;
+                    median: number;
+                    sampleCount: number;
+                    columnNorms: {
+                        neuron: number;
+                        norm: number;
+                    }[];
+                }[];
+                durationMs: number;
+                captureCount: number;
+            }[];
+            captures: {
+                promptId: string;
+                variantId: string;
+                layer: number;
+                neuron: number;
+                tokenIndex: number;
+                tokenId: number;
+                before: number;
+                after: number;
+            }[];
+            contentHash: string;
+        };
+    };
+    recording: {
+        schemaVersion: "openpond.modificationRecording.v1";
+        id: string;
+        teamId: string;
+        actorId: string;
+        operationId: string;
+        commandHash: string;
+        name: string;
+        projectId: string | null;
+        method: "inspect_activations" | "neuron_steering";
+        accountScopeHash: string;
+        custody: "local";
+        provenance: "external_observation";
+        measurementAttestation: "unattested";
+        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[];
+        };
+        inputHash: string;
+        resultHash: string;
+        artifact: {
+            contentHash: string;
+            sizeBytes: number;
+        };
+        counts: {
+            prompts: number;
+            variants: number;
+            outcomes: number;
+            captures: number;
+        };
+        createdAt: string;
+        contentHash: string;
+    };
+}>;
+export declare function createModificationRecordingsClient(request: (path: string, init?: RequestInit, responseLimit?: number) => Promise<unknown>): {
+    recordModificationObservation(raw: ModificationRecordingRequest): Promise<{
+        schemaVersion: "openpond.modificationRecording.v1";
+        id: string;
+        teamId: string;
+        actorId: string;
+        operationId: string;
+        commandHash: string;
+        name: string;
+        projectId: string | null;
+        method: "inspect_activations" | "neuron_steering";
+        accountScopeHash: string;
+        custody: "local";
+        provenance: "external_observation";
+        measurementAttestation: "unattested";
+        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[];
+        };
+        inputHash: string;
+        resultHash: string;
+        artifact: {
+            contentHash: string;
+            sizeBytes: number;
+        };
+        counts: {
+            prompts: number;
+            variants: number;
+            outcomes: number;
+            captures: number;
+        };
+        createdAt: string;
+        contentHash: string;
+    }>;
+    modificationRecording(id: string, query: {
+        teamId: string;
+    }): Promise<{
+        document: {
+            request: {
+                schemaVersion: "openpond.activationReferenceRequest.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[];
+                };
+                startingProfile?: {
+                    modelProjectId: string;
+                    versionHash: string;
+                    publication: {
+                        id: string;
+                        revision: number;
+                        contentHash: string;
+                    };
+                    profileHash: string;
+                    variantId: string;
+                } | undefined;
+                prompts: {
+                    id: string;
+                    tokenIds: number[];
+                    attentionMask: (0 | 1)[];
+                }[];
+                variants: {
+                    id: string;
+                    profile: {
+                        schemaVersion: "openpond.neuronSteeringProfile.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[];
+                        };
+                        hook: "mlp.down_proj.input";
+                        operation: "add";
+                        normalization: {
+                            mode: "baseline_prompt_residual_median";
+                            statistic: "midpoint_median_fp32";
+                            sample: "non_padding_prompt_after_position_zero";
+                        } | {
+                            mode: "fixed_residual_reference";
+                            calibration: {
+                                id: string;
+                                revision: number;
+                                contentHash: string;
+                            };
+                        };
+                        tokenScope: {
+                            phase: "decode_only" | "prompt_and_decode" | "prompt_only";
+                            positions: "after_position_zero" | "all_non_padding";
+                        };
+                        entries: {
+                            layer: number;
+                            neuron: number;
+                            dose: number;
+                        }[];
+                        contentHash: string;
+                    } | null;
+                }[];
+                capture: {
+                    layer: number;
+                    neurons: number[];
+                }[];
+                maxNewTokens: number;
+                eosTokenIds: number[];
+                maximumCapturedValues: number;
+                maximumForwardTokenWork: number;
+                maximumDurationSeconds: number;
+            };
+            result: {
+                schemaVersion: "openpond.activationReferenceResult.v1";
+                requestHash: string;
+                modelHash: string;
+                runtime: {
+                    implementation: "torch_dense_serial_reference_v1";
+                    implementationHash: string;
+                    torchVersion: string;
+                    device: string;
+                };
+                outcomes: {
+                    promptId: string;
+                    variantId: string;
+                    profileHash: string | null;
+                    generatedTokenIds: number[];
+                    forwardTokenWork: number;
+                    calibration: {
+                        layer: number;
+                        median: number;
+                        sampleCount: number;
+                        columnNorms: {
+                            neuron: number;
+                            norm: number;
+                        }[];
+                    }[];
+                    durationMs: number;
+                    captureCount: number;
+                }[];
+                captures: {
+                    promptId: string;
+                    variantId: string;
+                    layer: number;
+                    neuron: number;
+                    tokenIndex: number;
+                    tokenId: number;
+                    before: number;
+                    after: number;
+                }[];
+                contentHash: string;
+            };
+        };
+        recording: {
+            schemaVersion: "openpond.modificationRecording.v1";
+            id: string;
+            teamId: string;
+            actorId: string;
+            operationId: string;
+            commandHash: string;
+            name: string;
+            projectId: string | null;
+            method: "inspect_activations" | "neuron_steering";
+            accountScopeHash: string;
+            custody: "local";
+            provenance: "external_observation";
+            measurementAttestation: "unattested";
+            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[];
+            };
+            inputHash: string;
+            resultHash: string;
+            artifact: {
+                contentHash: string;
+                sizeBytes: number;
+            };
+            counts: {
+                prompts: number;
+                variants: number;
+                outcomes: number;
+                captures: number;
+            };
+            createdAt: string;
+            contentHash: string;
+        };
+    }>;
+    modificationRecordings(raw: ModificationRecordingListQuery): Promise<{
+        teamId: string;
+        actorId: string;
+        accountScopeHash: string;
+        projectId: string | null;
+        items: {
+            schemaVersion: "openpond.modificationRecording.v1";
+            id: string;
+            teamId: string;
+            actorId: string;
+            operationId: string;
+            commandHash: string;
+            name: string;
+            projectId: string | null;
+            method: "inspect_activations" | "neuron_steering";
+            accountScopeHash: string;
+            custody: "local";
+            provenance: "external_observation";
+            measurementAttestation: "unattested";
+            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[];
+            };
+            inputHash: string;
+            resultHash: string;
+            artifact: {
+                contentHash: string;
+                sizeBytes: number;
+            };
+            counts: {
+                prompts: number;
+                variants: number;
+                outcomes: number;
+                captures: number;
+            };
+            createdAt: string;
+            contentHash: string;
+        }[];
+        nextCursor: string | null;
+    }>;
+};
+//# sourceMappingURL=modification-recordings.d.ts.map