openpond-sdk 0.12.13 → 0.12.15

package/dist/types/packages/sdk/src/engram-adapter.d.ts

@@ -0,0 +1,788 @@
+import { z } from "zod";
+import { NeuronSteeringModelSchema } from "./neuron-steering.js";
+export declare const ENGRAM_ADAPTER_MAX_BYTES = 2147483648;
+/** Independent implementation of arXiv:2608.29327v1, section 3 and appendix B.
+ * Explicit boundary, initialization and history choices identify this runtime;
+ * the paper's reported retention is not a guarantee for a trained module. */
+export declare const EngramAdapterConfigSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.engramAdapterConfig.v1">;
+    implementation: z.ZodLiteral<"openpond_qwen_engram_paper_v1">;
+    hook: z.ZodLiteral<"self_attn.input">;
+    injectLayers: z.ZodTuple<[z.ZodLiteral<1>, z.ZodLiteral<3>, z.ZodLiteral<7>, z.ZodLiteral<15>], null>;
+    suffixOrders: z.ZodTuple<[z.ZodLiteral<2>, z.ZodLiteral<3>], null>;
+    previousOrders: z.ZodTuple<[z.ZodLiteral<3>], null>;
+    numHashes: z.ZodLiteral<4>;
+    tableSize: z.ZodLiteral<90007>;
+    perHashDim: z.ZodUnion<readonly [z.ZodLiteral<128>, z.ZodLiteral<256>]>;
+    alpha: z.ZodLiteral<0.2>;
+    memoryInitStd: z.ZodLiteral<0.02>;
+    adapterDtype: z.ZodLiteral<"float32">;
+    projectionInit: z.ZodLiteral<"zeros">;
+    gateInit: z.ZodLiteral<"zeros_no_bias">;
+    boundary: z.ZodLiteral<"incomplete_group_off_v1">;
+    occupancy: z.ZodLiteral<"training_before_lookup_v1">;
+    history: z.ZodLiteral<"request_absolute_positions_v1">;
+    batchSize: z.ZodLiteral<1>;
+}, z.core.$strict>;
+export type EngramAdapterConfig = z.infer<typeof EngramAdapterConfigSchema>;
+export declare const EngramTrainingSettingsSchema: z.ZodObject<{
+    learningRate: z.ZodNumber;
+    weightDecay: z.ZodNumber;
+    maxSteps: z.ZodNumber;
+    gradientAccumulationSteps: z.ZodNumber;
+    maxSequenceLength: z.ZodNumber;
+    seed: z.ZodNumber;
+    maxDurationSeconds: z.ZodNumber;
+    maxCheckpointBytes: z.ZodNumber;
+}, z.core.$strict>;
+export type EngramTrainingSettings = z.infer<typeof EngramTrainingSettingsSchema>;
+export declare const EngramTrainingDataSchema: 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>;
+export declare const EngramArtifactReferenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export declare const EngramTrainingRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.engramTrainingRequest.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<{
+        batch: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        examplesSha256: z.ZodString;
+        encodingHash: z.ZodString;
+    }, z.core.$strict>;
+    config: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.engramAdapterConfig.v1">;
+        implementation: z.ZodLiteral<"openpond_qwen_engram_paper_v1">;
+        hook: z.ZodLiteral<"self_attn.input">;
+        injectLayers: z.ZodTuple<[z.ZodLiteral<1>, z.ZodLiteral<3>, z.ZodLiteral<7>, z.ZodLiteral<15>], null>;
+        suffixOrders: z.ZodTuple<[z.ZodLiteral<2>, z.ZodLiteral<3>], null>;
+        previousOrders: z.ZodTuple<[z.ZodLiteral<3>], null>;
+        numHashes: z.ZodLiteral<4>;
+        tableSize: z.ZodLiteral<90007>;
+        perHashDim: z.ZodUnion<readonly [z.ZodLiteral<128>, z.ZodLiteral<256>]>;
+        alpha: z.ZodLiteral<0.2>;
+        memoryInitStd: z.ZodLiteral<0.02>;
+        adapterDtype: z.ZodLiteral<"float32">;
+        projectionInit: z.ZodLiteral<"zeros">;
+        gateInit: z.ZodLiteral<"zeros_no_bias">;
+        boundary: z.ZodLiteral<"incomplete_group_off_v1">;
+        occupancy: z.ZodLiteral<"training_before_lookup_v1">;
+        history: z.ZodLiteral<"request_absolute_positions_v1">;
+        batchSize: z.ZodLiteral<1>;
+    }, z.core.$strict>;
+    training: z.ZodObject<{
+        learningRate: z.ZodNumber;
+        weightDecay: z.ZodNumber;
+        maxSteps: z.ZodNumber;
+        gradientAccumulationSteps: z.ZodNumber;
+        maxSequenceLength: z.ZodNumber;
+        seed: z.ZodNumber;
+        maxDurationSeconds: z.ZodNumber;
+        maxCheckpointBytes: z.ZodNumber;
+    }, z.core.$strict>;
+    parentArtifact: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EngramTrainingRequest = z.infer<typeof EngramTrainingRequestSchema>;
+export declare const EngramSupervisedEncodingSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.engramSupervisedEncoding.v1">;
+    implementation: z.ZodLiteral<"supervised_trainer.prepare_example.v1">;
+    modelHash: z.ZodString;
+    tokenizerHash: z.ZodString;
+    maxSequenceLength: z.ZodNumber;
+    completionOnly: z.ZodLiteral<true>;
+    enableThinking: z.ZodLiteral<false>;
+    truncation: z.ZodLiteral<"left_prompt_preserve_final_target_v1">;
+}, z.core.$strict>;
+/** Declares the exact existing supervised encoder. This is not a claim that
+ * the caller measured tokenization or inspected private Dataset examples. */
+export declare function engramSupervisedEncoding(model: z.infer<typeof NeuronSteeringModelSchema>, maxSequenceLength: number): Promise<{
+    schemaVersion: "openpond.engramSupervisedEncoding.v1";
+    implementation: "supervised_trainer.prepare_example.v1";
+    modelHash: string;
+    tokenizerHash: string;
+    maxSequenceLength: number;
+    completionOnly: true;
+    enableThinking: false;
+    truncation: "left_prompt_preserve_final_target_v1";
+}>;
+export declare function parseAndVerifyEngramTrainingRequest(raw: unknown): Promise<{
+    schemaVersion: "openpond.engramTrainingRequest.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: {
+        batch: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        examplesSha256: string;
+        encodingHash: string;
+    };
+    config: {
+        schemaVersion: "openpond.engramAdapterConfig.v1";
+        implementation: "openpond_qwen_engram_paper_v1";
+        hook: "self_attn.input";
+        injectLayers: [1, 3, 7, 15];
+        suffixOrders: [2, 3];
+        previousOrders: [3];
+        numHashes: 4;
+        tableSize: 90007;
+        perHashDim: 128 | 256;
+        alpha: 0.2;
+        memoryInitStd: 0.02;
+        adapterDtype: "float32";
+        projectionInit: "zeros";
+        gateInit: "zeros_no_bias";
+        boundary: "incomplete_group_off_v1";
+        occupancy: "training_before_lookup_v1";
+        history: "request_absolute_positions_v1";
+        batchSize: 1;
+    };
+    training: {
+        learningRate: number;
+        weightDecay: number;
+        maxSteps: number;
+        gradientAccumulationSteps: number;
+        maxSequenceLength: number;
+        seed: number;
+        maxDurationSeconds: number;
+        maxCheckpointBytes: number;
+    };
+    parentArtifact: {
+        id: string;
+        contentHash: string;
+    } | null;
+}>;
+export declare const EngramArtifactPinsSchema: 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>;
+    adapterConfigHash: z.ZodString;
+    recipeHash: z.ZodString;
+    dataHash: z.ZodString;
+    data: 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>;
+    runtimeHash: z.ZodString;
+    parentArtifactHash: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const EngramAdapterTensorSchema: z.ZodObject<{
+    name: z.ZodString;
+    shape: z.ZodArray<z.ZodNumber>;
+    dtype: z.ZodEnum<{
+        BOOL: "BOOL";
+        F32: "F32";
+    }>;
+}, z.core.$strict>;
+export declare const EngramAdapterArtifactContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.engramAdapterArtifact.v1">;
+    method: z.ZodLiteral<"engram_adapter">;
+    config: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.engramAdapterConfig.v1">;
+        implementation: z.ZodLiteral<"openpond_qwen_engram_paper_v1">;
+        hook: z.ZodLiteral<"self_attn.input">;
+        injectLayers: z.ZodTuple<[z.ZodLiteral<1>, z.ZodLiteral<3>, z.ZodLiteral<7>, z.ZodLiteral<15>], null>;
+        suffixOrders: z.ZodTuple<[z.ZodLiteral<2>, z.ZodLiteral<3>], null>;
+        previousOrders: z.ZodTuple<[z.ZodLiteral<3>], null>;
+        numHashes: z.ZodLiteral<4>;
+        tableSize: z.ZodLiteral<90007>;
+        perHashDim: z.ZodUnion<readonly [z.ZodLiteral<128>, z.ZodLiteral<256>]>;
+        alpha: z.ZodLiteral<0.2>;
+        memoryInitStd: z.ZodLiteral<0.02>;
+        adapterDtype: z.ZodLiteral<"float32">;
+        projectionInit: z.ZodLiteral<"zeros">;
+        gateInit: z.ZodLiteral<"zeros_no_bias">;
+        boundary: z.ZodLiteral<"incomplete_group_off_v1">;
+        occupancy: z.ZodLiteral<"training_before_lookup_v1">;
+        history: z.ZodLiteral<"request_absolute_positions_v1">;
+        batchSize: z.ZodLiteral<1>;
+    }, 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>;
+        adapterConfigHash: z.ZodString;
+        recipeHash: z.ZodString;
+        dataHash: z.ZodString;
+        data: 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>;
+        runtimeHash: z.ZodString;
+        parentArtifactHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    payload: z.ZodObject<{
+        path: z.ZodLiteral<"adapter.safetensors">;
+        sha256: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        tensors: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            shape: z.ZodArray<z.ZodNumber>;
+            dtype: z.ZodEnum<{
+                BOOL: "BOOL";
+                F32: "F32";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const EngramAdapterArtifactSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.engramAdapterArtifact.v1">;
+    method: z.ZodLiteral<"engram_adapter">;
+    config: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.engramAdapterConfig.v1">;
+        implementation: z.ZodLiteral<"openpond_qwen_engram_paper_v1">;
+        hook: z.ZodLiteral<"self_attn.input">;
+        injectLayers: z.ZodTuple<[z.ZodLiteral<1>, z.ZodLiteral<3>, z.ZodLiteral<7>, z.ZodLiteral<15>], null>;
+        suffixOrders: z.ZodTuple<[z.ZodLiteral<2>, z.ZodLiteral<3>], null>;
+        previousOrders: z.ZodTuple<[z.ZodLiteral<3>], null>;
+        numHashes: z.ZodLiteral<4>;
+        tableSize: z.ZodLiteral<90007>;
+        perHashDim: z.ZodUnion<readonly [z.ZodLiteral<128>, z.ZodLiteral<256>]>;
+        alpha: z.ZodLiteral<0.2>;
+        memoryInitStd: z.ZodLiteral<0.02>;
+        adapterDtype: z.ZodLiteral<"float32">;
+        projectionInit: z.ZodLiteral<"zeros">;
+        gateInit: z.ZodLiteral<"zeros_no_bias">;
+        boundary: z.ZodLiteral<"incomplete_group_off_v1">;
+        occupancy: z.ZodLiteral<"training_before_lookup_v1">;
+        history: z.ZodLiteral<"request_absolute_positions_v1">;
+        batchSize: z.ZodLiteral<1>;
+    }, 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>;
+        adapterConfigHash: z.ZodString;
+        recipeHash: z.ZodString;
+        dataHash: z.ZodString;
+        data: 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>;
+        runtimeHash: z.ZodString;
+        parentArtifactHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    payload: z.ZodObject<{
+        path: z.ZodLiteral<"adapter.safetensors">;
+        sha256: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        tensors: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            shape: z.ZodArray<z.ZodNumber>;
+            dtype: z.ZodEnum<{
+                BOOL: "BOOL";
+                F32: "F32";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type EngramAdapterArtifact = z.infer<typeof EngramAdapterArtifactSchema>;
+export declare function engramAdapterTensorInventory(config: EngramAdapterConfig, hiddenSize: number): {
+    name: string;
+    shape: number[];
+    dtype: "BOOL" | "F32";
+}[];
+/** Metadata verification does not prove possession of the tensor bytes. The
+ * artifact custodian must separately verify their size, digest and inventory. */
+export declare function parseAndVerifyEngramAdapterArtifact(raw: unknown, expected?: {
+    request: EngramTrainingRequest;
+    runtimeHash: string;
+}): Promise<{
+    schemaVersion: "openpond.engramAdapterArtifact.v1";
+    method: "engram_adapter";
+    config: {
+        schemaVersion: "openpond.engramAdapterConfig.v1";
+        implementation: "openpond_qwen_engram_paper_v1";
+        hook: "self_attn.input";
+        injectLayers: [1, 3, 7, 15];
+        suffixOrders: [2, 3];
+        previousOrders: [3];
+        numHashes: 4;
+        tableSize: 90007;
+        perHashDim: 128 | 256;
+        alpha: 0.2;
+        memoryInitStd: 0.02;
+        adapterDtype: "float32";
+        projectionInit: "zeros";
+        gateInit: "zeros_no_bias";
+        boundary: "incomplete_group_off_v1";
+        occupancy: "training_before_lookup_v1";
+        history: "request_absolute_positions_v1";
+        batchSize: 1;
+    };
+    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[];
+        };
+        adapterConfigHash: string;
+        recipeHash: string;
+        dataHash: string;
+        data: {
+            batch: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            examplesSha256: string;
+            encodingHash: string;
+        };
+        runtimeHash: string;
+        parentArtifactHash: string | null;
+    };
+    payload: {
+        path: "adapter.safetensors";
+        sha256: string;
+        sizeBytes: number;
+        tensors: {
+            name: string;
+            shape: number[];
+            dtype: "BOOL" | "F32";
+        }[];
+    };
+    contentHash: string;
+}>;
+export declare const EngramModuleFileSchema: z.ZodObject<{
+    path: z.ZodEnum<{
+        "adapter.safetensors": "adapter.safetensors";
+        "manifest.json": "manifest.json";
+    }>;
+    artifactId: z.ZodString;
+    sha256: z.ZodString;
+    sizeBytes: z.ZodNumber;
+}, z.core.$strict>;
+export declare const EngramTrainingResultContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.engramTrainingResult.v1">;
+    inputHash: z.ZodString;
+    modelHash: z.ZodString;
+    runtimeHash: z.ZodString;
+    dataHash: z.ZodString;
+    preparedRowsHash: z.ZodString;
+    optimizerSteps: z.ZodNumber;
+    examplesProcessed: z.ZodNumber;
+    targetTokens: z.ZodNumber;
+    forwardTokenWork: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    meanLoss: z.ZodNumber;
+    finalLoss: z.ZodNumber;
+    baseWeightsHashBefore: z.ZodString;
+    baseWeightsHashAfter: z.ZodString;
+    baseOptimizerParameterCount: z.ZodLiteral<0>;
+    baseGradientParameterCount: z.ZodLiteral<0>;
+    artifact: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.engramAdapterArtifact.v1">;
+            method: z.ZodLiteral<"engram_adapter">;
+            config: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.engramAdapterConfig.v1">;
+                implementation: z.ZodLiteral<"openpond_qwen_engram_paper_v1">;
+                hook: z.ZodLiteral<"self_attn.input">;
+                injectLayers: z.ZodTuple<[z.ZodLiteral<1>, z.ZodLiteral<3>, z.ZodLiteral<7>, z.ZodLiteral<15>], null>;
+                suffixOrders: z.ZodTuple<[z.ZodLiteral<2>, z.ZodLiteral<3>], null>;
+                previousOrders: z.ZodTuple<[z.ZodLiteral<3>], null>;
+                numHashes: z.ZodLiteral<4>;
+                tableSize: z.ZodLiteral<90007>;
+                perHashDim: z.ZodUnion<readonly [z.ZodLiteral<128>, z.ZodLiteral<256>]>;
+                alpha: z.ZodLiteral<0.2>;
+                memoryInitStd: z.ZodLiteral<0.02>;
+                adapterDtype: z.ZodLiteral<"float32">;
+                projectionInit: z.ZodLiteral<"zeros">;
+                gateInit: z.ZodLiteral<"zeros_no_bias">;
+                boundary: z.ZodLiteral<"incomplete_group_off_v1">;
+                occupancy: z.ZodLiteral<"training_before_lookup_v1">;
+                history: z.ZodLiteral<"request_absolute_positions_v1">;
+                batchSize: z.ZodLiteral<1>;
+            }, 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>;
+                adapterConfigHash: z.ZodString;
+                recipeHash: z.ZodString;
+                dataHash: z.ZodString;
+                data: 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>;
+                runtimeHash: z.ZodString;
+                parentArtifactHash: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            payload: z.ZodObject<{
+                path: z.ZodLiteral<"adapter.safetensors">;
+                sha256: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                tensors: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    shape: z.ZodArray<z.ZodNumber>;
+                    dtype: z.ZodEnum<{
+                        BOOL: "BOOL";
+                        F32: "F32";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodEnum<{
+                "adapter.safetensors": "adapter.safetensors";
+                "manifest.json": "manifest.json";
+            }>;
+            artifactId: z.ZodString;
+            sha256: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const EngramTrainingResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.engramTrainingResult.v1">;
+    inputHash: z.ZodString;
+    modelHash: z.ZodString;
+    runtimeHash: z.ZodString;
+    dataHash: z.ZodString;
+    preparedRowsHash: z.ZodString;
+    optimizerSteps: z.ZodNumber;
+    examplesProcessed: z.ZodNumber;
+    targetTokens: z.ZodNumber;
+    forwardTokenWork: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    meanLoss: z.ZodNumber;
+    finalLoss: z.ZodNumber;
+    baseWeightsHashBefore: z.ZodString;
+    baseWeightsHashAfter: z.ZodString;
+    baseOptimizerParameterCount: z.ZodLiteral<0>;
+    baseGradientParameterCount: z.ZodLiteral<0>;
+    artifact: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.engramAdapterArtifact.v1">;
+            method: z.ZodLiteral<"engram_adapter">;
+            config: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.engramAdapterConfig.v1">;
+                implementation: z.ZodLiteral<"openpond_qwen_engram_paper_v1">;
+                hook: z.ZodLiteral<"self_attn.input">;
+                injectLayers: z.ZodTuple<[z.ZodLiteral<1>, z.ZodLiteral<3>, z.ZodLiteral<7>, z.ZodLiteral<15>], null>;
+                suffixOrders: z.ZodTuple<[z.ZodLiteral<2>, z.ZodLiteral<3>], null>;
+                previousOrders: z.ZodTuple<[z.ZodLiteral<3>], null>;
+                numHashes: z.ZodLiteral<4>;
+                tableSize: z.ZodLiteral<90007>;
+                perHashDim: z.ZodUnion<readonly [z.ZodLiteral<128>, z.ZodLiteral<256>]>;
+                alpha: z.ZodLiteral<0.2>;
+                memoryInitStd: z.ZodLiteral<0.02>;
+                adapterDtype: z.ZodLiteral<"float32">;
+                projectionInit: z.ZodLiteral<"zeros">;
+                gateInit: z.ZodLiteral<"zeros_no_bias">;
+                boundary: z.ZodLiteral<"incomplete_group_off_v1">;
+                occupancy: z.ZodLiteral<"training_before_lookup_v1">;
+                history: z.ZodLiteral<"request_absolute_positions_v1">;
+                batchSize: z.ZodLiteral<1>;
+            }, 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>;
+                adapterConfigHash: z.ZodString;
+                recipeHash: z.ZodString;
+                dataHash: z.ZodString;
+                data: 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>;
+                runtimeHash: z.ZodString;
+                parentArtifactHash: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            payload: z.ZodObject<{
+                path: z.ZodLiteral<"adapter.safetensors">;
+                sha256: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                tensors: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    shape: z.ZodArray<z.ZodNumber>;
+                    dtype: z.ZodEnum<{
+                        BOOL: "BOOL";
+                        F32: "F32";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodEnum<{
+                "adapter.safetensors": "adapter.safetensors";
+                "manifest.json": "manifest.json";
+            }>;
+            artifactId: z.ZodString;
+            sha256: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type EngramTrainingResult = z.infer<typeof EngramTrainingResultSchema>;
+/** Successful results require exact committed file custody as well as the
+ * producer's training evidence. A manifest alone is not a trained Model. */
+export declare function parseAndVerifyEngramTrainingResult(raw: unknown, expected: {
+    request: EngramTrainingRequest;
+    runtimeHash: string;
+}): Promise<{
+    schemaVersion: "openpond.engramTrainingResult.v1";
+    inputHash: string;
+    modelHash: string;
+    runtimeHash: string;
+    dataHash: string;
+    preparedRowsHash: string;
+    optimizerSteps: number;
+    examplesProcessed: number;
+    targetTokens: number;
+    forwardTokenWork: number;
+    durationMs: number;
+    meanLoss: number;
+    finalLoss: number;
+    baseWeightsHashBefore: string;
+    baseWeightsHashAfter: string;
+    baseOptimizerParameterCount: 0;
+    baseGradientParameterCount: 0;
+    artifact: {
+        id: string;
+        contentHash: string;
+        manifest: {
+            schemaVersion: "openpond.engramAdapterArtifact.v1";
+            method: "engram_adapter";
+            config: {
+                schemaVersion: "openpond.engramAdapterConfig.v1";
+                implementation: "openpond_qwen_engram_paper_v1";
+                hook: "self_attn.input";
+                injectLayers: [1, 3, 7, 15];
+                suffixOrders: [2, 3];
+                previousOrders: [3];
+                numHashes: 4;
+                tableSize: 90007;
+                perHashDim: 128 | 256;
+                alpha: 0.2;
+                memoryInitStd: 0.02;
+                adapterDtype: "float32";
+                projectionInit: "zeros";
+                gateInit: "zeros_no_bias";
+                boundary: "incomplete_group_off_v1";
+                occupancy: "training_before_lookup_v1";
+                history: "request_absolute_positions_v1";
+                batchSize: 1;
+            };
+            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[];
+                };
+                adapterConfigHash: string;
+                recipeHash: string;
+                dataHash: string;
+                data: {
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    examplesSha256: string;
+                    encodingHash: string;
+                };
+                runtimeHash: string;
+                parentArtifactHash: string | null;
+            };
+            payload: {
+                path: "adapter.safetensors";
+                sha256: string;
+                sizeBytes: number;
+                tensors: {
+                    name: string;
+                    shape: number[];
+                    dtype: "BOOL" | "F32";
+                }[];
+            };
+            contentHash: string;
+        };
+        files: {
+            path: "adapter.safetensors" | "manifest.json";
+            artifactId: string;
+            sha256: string;
+            sizeBytes: number;
+        }[];
+    };
+    contentHash: string;
+}>;
+//# sourceMappingURL=engram-adapter.d.ts.map