@simulatte/doppler 0.1.6 → 0.1.7

package/src/gpu/profiler.js

@@ -179,6 +179,8 @@ export class GPUProfiler {
 
     if (!this.#device || !this.#querySet || !this.#queryBuffer || !this.#readbackBuffer) {
       log.warn('GPUProfiler', 'Missing required resources for resolve');
+      this.#pendingResolves = [];
+      this.#nextQueryIndex = 0;
       return;
     }
 
@@ -199,34 +201,35 @@ export class GPUProfiler {
 
     this.#device.queue.submit([encoder.finish()]);
 
-    if (!allowReadback('GPUProfiler.resolve')) {
-      return;
-    }
+    let mapped = false;
 
-    // Read back timestamps
-    await this.#readbackBuffer.mapAsync(GPUMapMode.READ);
-    const timestamps = new BigUint64Array(this.#readbackBuffer.getMappedRange());
+    try {
+      if (!allowReadback('GPUProfiler.resolve')) {
+        return;
+      }
 
-    // Process pending resolves
-    for (const pending of this.#pendingResolves) {
-      const startNs = timestamps[pending.startIndex];
-      const endNs = timestamps[pending.endIndex];
+      await this.#readbackBuffer.mapAsync(GPUMapMode.READ);
+      mapped = true;
+      const timestamps = new BigUint64Array(this.#readbackBuffer.getMappedRange());
 
-      // Convert nanoseconds to milliseconds
-      const durationMs = Number(endNs - startNs) / 1_000_000;
+      for (const pending of this.#pendingResolves) {
+        const startNs = timestamps[pending.startIndex];
+        const endNs = timestamps[pending.endIndex];
+        const durationMs = Number(endNs - startNs) / 1_000_000;
 
-      // Sanity check - use CPU timing if GPU timing seems wrong
-      if (durationMs < 0 || durationMs > this.#maxDurationMs) {
-        // Fallback to CPU timing
-        this.#recordResult(pending.label, pending.cpuEndTime - pending.cpuStartTime);
-      } else {
-        this.#recordResult(pending.label, durationMs);
+        if (durationMs < 0 || durationMs > this.#maxDurationMs) {
+          this.#recordResult(pending.label, pending.cpuEndTime - pending.cpuStartTime);
+        } else {
+          this.#recordResult(pending.label, durationMs);
+        }
+      }
+    } finally {
+      if (mapped) {
+        this.#readbackBuffer.unmap();
       }
+      this.#pendingResolves = [];
+      this.#nextQueryIndex = 0;
     }
-
-    this.#readbackBuffer.unmap();
-    this.#pendingResolves = [];
-    this.#nextQueryIndex = 0;
   }
 
   
@@ -350,6 +353,8 @@ export class GPUProfiler {
     }
     this.#results.clear();
     this.#activeLabels.clear();
+    this.#pendingResolves = [];
+    this.#nextQueryIndex = 0;
   }
 }
 

package/src/gpu/readback-utils.d.ts

@@ -0,0 +1,16 @@
+export interface ReadbackBufferEntry {
+  buffer: GPUBuffer;
+  destroy?: boolean;
+  offset?: number;
+  size?: number;
+}
+
+export function withMappedReadBuffer<T>(
+  buffer: GPUBuffer,
+  read: (range: ArrayBuffer) => T | Promise<T>,
+): Promise<T>;
+
+export function withMappedReadBuffers<T>(
+  entries: ReadonlyArray<ReadbackBufferEntry>,
+  read: (ranges: Array<ArrayBuffer>) => T | Promise<T>,
+): Promise<T>;

package/src/gpu/readback-utils.js

@@ -0,0 +1,41 @@
+export async function withMappedReadBuffer(buffer, read) {
+  let mapped = false;
+  try {
+    await buffer.mapAsync(GPUMapMode.READ);
+    mapped = true;
+    return await read(buffer.getMappedRange());
+  } finally {
+    if (mapped) {
+      buffer.unmap();
+    }
+  }
+}
+
+export async function withMappedReadBuffers(entries, read) {
+  const mappedEntries = [];
+  try {
+    await Promise.all(entries.map(async (entry) => {
+      await entry.buffer.mapAsync(GPUMapMode.READ);
+      mappedEntries.push(entry);
+    }));
+    const ranges = entries.map((entry) => {
+      if (entry.offset != null || entry.size != null) {
+        return entry.buffer.getMappedRange(
+          entry.offset ?? 0,
+          entry.size ?? (entry.buffer.size - (entry.offset ?? 0))
+        );
+      }
+      return entry.buffer.getMappedRange();
+    });
+    return await read(ranges);
+  } finally {
+    for (let index = mappedEntries.length - 1; index >= 0; index -= 1) {
+      mappedEntries[index].buffer.unmap();
+    }
+    for (const entry of entries) {
+      if (entry.destroy === true) {
+        entry.buffer.destroy();
+      }
+    }
+  }
+}

package/src/gpu/submit-tracker.js

@@ -21,6 +21,8 @@ let submitSources = new Map();
 
 let currentPhase = 'other';
 
+const WRAPPED_QUEUE_SENTINEL = Symbol.for('doppler.submitTrackerWrapped');
+
 
 const phaseStats = {
   prefill: { count: 0, times: [], totalMs: 0, maxMs: 0, minMs: Infinity, sources: new Map() },
@@ -194,6 +196,10 @@ function extractSourceFromStack() {
 
 
 export function wrapQueueForTracking(queue) {
+  if (!queue || queue[WRAPPED_QUEUE_SENTINEL] === true) {
+    return queue;
+  }
+
   const originalSubmit = queue.submit.bind(queue);
 
    (queue).submit = function( commandBuffers) {
@@ -210,6 +216,13 @@ export function wrapQueueForTracking(queue) {
     return result;
   };
 
+  Object.defineProperty(queue, WRAPPED_QUEUE_SENTINEL, {
+    value: true,
+    configurable: true,
+    enumerable: false,
+    writable: false,
+  });
+
   return queue;
 }
 

package/src/gpu/uniform-cache.d.ts

@@ -8,6 +8,7 @@
 
 interface UniformCacheEntry {
   buffer: GPUBuffer;
+  bytes: Uint8Array;
   lastUsed: number;
   refCount: number;
 }

package/src/gpu/uniform-cache.js

@@ -17,6 +17,18 @@ function hashArrayBuffer(data) {
   return (hash >>> 0).toString(16).padStart(8, '0');
 }
 
+function copyUniformBytes(data) {
+  return new Uint8Array(data.slice(0));
+}
+
+function equalUniformBytes(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
 
 export class UniformBufferCache {
   
@@ -50,14 +62,22 @@ export class UniformBufferCache {
 
   
   getOrCreate(data, label) {
-    const hash = hashArrayBuffer(data);
-    const existing = this.#cache.get(hash);
-
-    if (existing) {
-      existing.lastUsed = performance.now();
-      existing.refCount++;
-      this.#stats.hits++;
-      return existing.buffer;
+    const baseKey = `${data.byteLength}:${hashArrayBuffer(data)}`;
+    const dataBytes = copyUniformBytes(data);
+    let key = baseKey;
+    let suffix = 0;
+    let existing = this.#cache.get(key);
+
+    while (existing) {
+      if (equalUniformBytes(existing.bytes, dataBytes)) {
+        existing.lastUsed = performance.now();
+        existing.refCount++;
+        this.#stats.hits++;
+        return existing.buffer;
+      }
+      suffix += 1;
+      key = `${baseKey}#${suffix}`;
+      existing = this.#cache.get(key);
     }
 
     // Cache miss - create new buffer
@@ -80,8 +100,9 @@ export class UniformBufferCache {
       this.#evictLRU();
     }
 
-    this.#cache.set(hash, {
+    this.#cache.set(key, {
       buffer,
+      bytes: dataBytes,
       lastUsed: performance.now(),
       refCount: 1,
     });

package/src/hotswap/intent-bundle.js

@@ -42,6 +42,9 @@ export async function verifyIntentBundle(bundle, context) {
     reasons.push('Missing payload.expectedOutputHash');
   }
 
+  if (baseModelHash && !context?.manifest) {
+    reasons.push('Missing verification context manifest');
+  }
   if (context?.manifest && baseModelHash) {
     const manifestHash = await computeManifestHash(context.manifest);
     if (manifestHash !== baseModelHash.replace('sha256:', '')) {
@@ -49,6 +52,9 @@ export async function verifyIntentBundle(bundle, context) {
     }
   }
 
+  if (kernelRegistryVersion && context?.kernelRegistryVersion == null) {
+    reasons.push('Missing verification context kernelRegistryVersion');
+  }
   if (context?.kernelRegistryVersion && kernelRegistryVersion) {
     if (context.kernelRegistryVersion !== kernelRegistryVersion) {
       reasons.push('Kernel registry version mismatch');

package/src/hotswap/manifest.d.ts

@@ -23,11 +23,20 @@ export interface HotSwapVerificationResult {
   signerId?: string;
 }
 
+export interface HotSwapVerificationContext {
+  source?: {
+    kind?: 'local' | 'remote' | string | null;
+    isLocal?: boolean | null;
+    url?: string | null;
+  } | null;
+}
+
 export declare function fetchHotSwapManifest(url: string): Promise<HotSwapManifest>;
 
 export declare function verifyHotSwapManifest(
   manifest: HotSwapManifest,
-  policy: HotSwapConfigSchema
+  policy: HotSwapConfigSchema,
+  context?: HotSwapVerificationContext
 ): Promise<HotSwapVerificationResult>;
 
 export declare function serializeHotSwapManifest(manifest: HotSwapManifest): string;

package/src/hotswap/manifest.js

@@ -14,13 +14,23 @@ export async function fetchHotSwapManifest(url) {
   return response.json();
 }
 
-export async function verifyHotSwapManifest(manifest, policy) {
+function isExplicitLocalSource(source) {
+  if (!source || typeof source !== 'object') {
+    return false;
+  }
+  if (source.isLocal === true) {
+    return true;
+  }
+  return source.kind === 'local';
+}
+
+export async function verifyHotSwapManifest(manifest, policy, context = {}) {
   if (!policy.enabled) {
     return { ok: false, reason: 'Hot-swap disabled' };
   }
 
   if (!manifest.signature) {
-    if (policy.localOnly && policy.allowUnsignedLocal) {
+    if (policy.localOnly && policy.allowUnsignedLocal && isExplicitLocalSource(context.source)) {
       return { ok: true, reason: 'Local-only unsigned manifest accepted' };
     }
     return { ok: false, reason: 'Signature required' };

package/src/hotswap/runtime.js

@@ -6,18 +6,40 @@ function normalizeRolloutPolicy(policy) {
     ? policy.rollout
     : {};
   const rawMode = String(rollout.mode || 'shadow').trim().toLowerCase().replace(/_/g, '-');
-  const mode = rawMode === 'default' || rawMode === 'canary' || rawMode === 'opt-in' || rawMode === 'shadow'
-    ? rawMode
-    : 'shadow';
-  const canaryPercent = Number.isFinite(rollout.canaryPercent)
-    ? Math.min(100, Math.max(0, Number(rollout.canaryPercent)))
-    : 0;
+  if (rawMode !== 'default' && rawMode !== 'canary' && rawMode !== 'opt-in' && rawMode !== 'shadow') {
+    throw new Error(
+      `hotswap.rollout.mode must be one of default, canary, opt-in, shadow (received "${rollout.mode}")`
+    );
+  }
+  let canaryPercent = 0;
+  if (rollout.canaryPercent !== undefined && rollout.canaryPercent !== null) {
+    const parsedCanaryPercent = Number(rollout.canaryPercent);
+    if (!Number.isFinite(parsedCanaryPercent) || parsedCanaryPercent < 0 || parsedCanaryPercent > 100) {
+      throw new Error('hotswap.rollout.canaryPercent must be a number between 0 and 100 when provided.');
+    }
+    canaryPercent = parsedCanaryPercent;
+  }
+  if (rollout.cohortSalt !== undefined && rollout.cohortSalt !== null && typeof rollout.cohortSalt !== 'string') {
+    throw new Error('hotswap.rollout.cohortSalt must be a string when provided.');
+  }
   const cohortSalt = String(rollout.cohortSalt || 'doppler-hotswap-v1').trim() || 'doppler-hotswap-v1';
+  if (rollout.optInAllowlist !== undefined && rollout.optInAllowlist !== null && !Array.isArray(rollout.optInAllowlist)) {
+    throw new Error('hotswap.rollout.optInAllowlist must be an array of strings when provided.');
+  }
   const optInAllowlist = Array.isArray(rollout.optInAllowlist)
-    ? rollout.optInAllowlist.map((entry) => String(entry || '').trim()).filter(Boolean)
+    ? rollout.optInAllowlist.map((entry, index) => {
+      if (typeof entry !== 'string') {
+        throw new Error(`hotswap.rollout.optInAllowlist[${index}] must be a string.`);
+      }
+      const normalized = entry.trim();
+      if (!normalized) {
+        throw new Error(`hotswap.rollout.optInAllowlist[${index}] must not be empty.`);
+      }
+      return normalized;
+    })
     : [];
   return {
-    mode,
+    mode: rawMode,
     canaryPercent,
     cohortSalt,
     optInAllowlist,

package/src/index-browser.d.ts

@@ -9,6 +9,20 @@ export {
 export { MultiModelLoader } from './loader/multi-model-loader.js';
 
 export { InferencePipeline, EmbeddingPipeline, createPipeline } from './generation/index.js';
+export {
+  StructuredJsonHeadPipeline,
+  isStructuredJsonHeadModelType,
+  createStructuredJsonHeadPipeline,
+  DreamStructuredPipeline,
+  isDreamStructuredModelType,
+  createDreamStructuredPipeline,
+} from './generation/index.js';
+export {
+  EnergyRowHeadPipeline,
+  createEnergyRowHeadPipeline,
+  DreamEnergyHeadPipeline,
+  createDreamEnergyHeadPipeline,
+} from './inference/pipelines/energy-head/row-head-pipeline.js';
 export { KVCache } from './inference/kv-cache.js';
 export { Tokenizer } from './inference/tokenizer.js';
 export { SpeculativeDecoder } from './inference/speculative.js';
@@ -25,6 +39,22 @@ export {
   mergeMultipleLogits,
 } from './gpu/kernels/logit-merge.js';
 
+export type { RDRRManifest, ShardInfo } from './formats/rdrr/index.js';
+export type { TensorLocation, LoadProgress, LoadOptions, LoaderStats } from './loader/doppler-loader.js';
+export type { AdapterSource } from './loader/multi-model-loader.js';
+export type { ParsedModelConfig } from './generation/index.js';
+export type { SamplingOptions } from './generation/index.js';
+export type {
+  GenerateOptions,
+  GenerationResult,
+  KVCacheSnapshot,
+  LayerWeights,
+  ExpertWeights,
+  RouterWeights,
+} from './generation/index.js';
+export type { LoRAAdapter, LoRAModuleName } from './generation/index.js';
+export type { ExpertNode, ExpertTask } from './inference/multi-model-network.js';
+
 export {
   ADAPTER_MANIFEST_SCHEMA,
   validateManifest as validateAdapterManifest,
@@ -45,4 +75,18 @@ export {
   createMemoryRegistry,
 } from './adapters/index.js';
 
+export type {
+  AdapterManifest,
+  AdapterMetadata,
+  AdapterTensorSpec,
+  LoRALoadOptions,
+  LoRAWeightsResult,
+  AdapterState,
+  EnableAdapterOptions,
+  AdapterStackOptions,
+  AdapterManagerEvents,
+  AdapterRegistryEntry,
+  AdapterQueryOptions,
+} from './adapters/index.js';
+
 export * from './tooling-exports.browser.js';

package/src/index-browser.js

@@ -11,6 +11,20 @@ export { MultiModelLoader } from './loader/multi-model-loader.js';
 
 // Inference pipeline
 export { InferencePipeline, EmbeddingPipeline, createPipeline } from './generation/index.js';
+export {
+  StructuredJsonHeadPipeline,
+  isStructuredJsonHeadModelType,
+  createStructuredJsonHeadPipeline,
+  DreamStructuredPipeline,
+  isDreamStructuredModelType,
+  createDreamStructuredPipeline,
+} from './generation/index.js';
+export {
+  EnergyRowHeadPipeline,
+  createEnergyRowHeadPipeline,
+  DreamEnergyHeadPipeline,
+  createDreamEnergyHeadPipeline,
+} from './inference/pipelines/energy-head/row-head-pipeline.js';
 export { KVCache } from './inference/kv-cache.js';
 export { Tokenizer } from './inference/tokenizer.js';
 export { SpeculativeDecoder } from './inference/speculative.js';

package/src/inference/browser-harness-contract-helpers.d.ts

@@ -0,0 +1,5 @@
+export declare function buildSuiteContractMetrics(
+  suite: string,
+  baseMetrics: Record<string, unknown>,
+  manifest: Record<string, unknown> | null | undefined
+): Record<string, unknown>;

package/src/inference/browser-harness-contract-helpers.js

@@ -0,0 +1,28 @@
+import { getInferenceLayerPatternContractArtifact } from '../rules/rule-registry.js';
+import { isPlainObject } from '../utils/plain-object.js';
+import { validateBrowserSuiteMetrics } from '../config/schema/browser-suite-metrics.schema.js';
+import { buildExecutionContractArtifact } from '../config/execution-contract-check.js';
+import { buildManifestRequiredInferenceFieldsArtifact } from '../config/required-inference-fields-contract-check.js';
+
+export function buildSuiteContractMetrics(suite, baseMetrics, manifest) {
+  const executionContractArtifact = buildExecutionContractArtifact(manifest);
+  const executionV0GraphContractArtifact = executionContractArtifact?.executionV0?.graph ?? null;
+  const layerPatternContractArtifact = getInferenceLayerPatternContractArtifact();
+  const requiredInferenceFieldsArtifact = manifest?.modelType === 'transformer'
+    && isPlainObject(manifest?.inference?.attention)
+    ? buildManifestRequiredInferenceFieldsArtifact(
+      manifest?.inference ?? null,
+      `${manifest?.modelId ?? 'unknown'}.inference`
+    )
+    : null;
+  return validateBrowserSuiteMetrics({
+    ...baseMetrics,
+    schemaVersion: 1,
+    source: 'doppler',
+    suite,
+    ...(executionContractArtifact ? { executionContractArtifact } : {}),
+    executionV0GraphContractArtifact,
+    layerPatternContractArtifact,
+    requiredInferenceFieldsArtifact,
+  });
+}

package/src/inference/browser-harness-diffusion-energy-suites.d.ts

@@ -0,0 +1,2 @@
+export declare function runDiffusionSuite(options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function runEnergySuite(options?: Record<string, unknown>): Promise<Record<string, unknown>>;