@simulatte/doppler 0.1.6 → 0.1.8

package/src/gpu/kernels/transpose.js

@@ -1,4 +1,4 @@
-import { acquireBuffer } from '../../memory/buffer-pool.js';
+import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
 import { createTensor, dtypeBytes } from '../tensor.js';
 import { WORKGROUP_SIZES } from './constants.js';
 import { unifiedKernelWrapper } from './utils.js';
@@ -20,18 +20,26 @@ async function _transpose(target, input, rows, cols, options = {}) {
   const bytesPerElement = dtypeBytes(input.dtype);
   const outputSize = rows * cols * bytesPerElement;
   const outputBuf = outputBuffer || acquireBuffer(outputSize, undefined, 'transpose_output');
+  const ownedOutput = outputBuffer ? null : outputBuf;
   const dispatchPlan = planTransposeDispatch(target, cols);
 
-  await unifiedKernelWrapper(
-    'transpose',
-    target,
-    'default',
-    [input, outputBuf],
-    { rows, cols, _pad0: dispatchPlan.dispatchStride, _pad1: 0 },
-    [dispatchPlan.workgroups[0], rows, 1]
-  );
+  try {
+    await unifiedKernelWrapper(
+      'transpose',
+      target,
+      'default',
+      [input, outputBuf],
+      { rows, cols, _pad0: dispatchPlan.dispatchStride, _pad1: 0 },
+      [dispatchPlan.workgroups[0], rows, 1]
+    );
 
-  return createTensor(outputBuf, input.dtype, [cols, rows], 'transpose_output');
+    return createTensor(outputBuf, input.dtype, [cols, rows], 'transpose_output');
+  } catch (error) {
+    if (ownedOutput) {
+      releaseBuffer(ownedOutput);
+    }
+    throw error;
+  }
 }
 
 export async function runTranspose(input, rows, cols, options = {}) {

package/src/gpu/kernels/transpose.wgsl

@@ -20,11 +20,13 @@ struct Uniforms {
 @compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let dispatch_stride = max(u._pad0, 1u);
-    let row = gid.y;
-    let col = gid.x + row * dispatch_stride;
-    if (row >= u.rows || col >= u.cols) {
+    let linear_idx = gid.y * dispatch_stride + gid.x;
+    let total = u.rows * u.cols;
+    if (linear_idx >= total) {
         return;
     }
+    let row = linear_idx / u.cols;
+    let col = linear_idx % u.cols;
     let idx = row * u.cols + col;
     let out_idx = col * u.rows + row;
     output[out_idx] = input[idx];

package/src/gpu/kernels/upsample2d.js

@@ -1,4 +1,4 @@
-import { acquireBuffer } from '../../memory/buffer-pool.js';
+import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
 import { createTensor, dtypeBytes } from '../tensor.js';
 import { unifiedKernelWrapper } from './utils.js';
 import { selectRuleValue } from './rule-registry.js';
@@ -35,19 +35,27 @@ async function _upsample2d(target, input, options = {}) {
   const bytesPerElement = dtypeBytes(input.dtype);
   const outputSize = channels * outHeight * outWidth * bytesPerElement;
   const output = outputBuffer || acquireBuffer(outputSize, undefined, 'upsample2d_output');
+  const ownedOutput = outputBuffer ? null : output;
 
-  await unifiedKernelWrapper(
-    'upsample2d', target, selectUpsample2DVariant(input.dtype === 'f16'),
-    [input, output],
-    {
-      channels, in_height: resolvedHeight, in_width: resolvedWidth,
-      out_height: outHeight, out_width: outWidth, scale,
-      _pad0: 0, _pad1: 0,
-    },
-    [Math.ceil(outSpatial / WORKGROUP_SIZES.DEFAULT), channels, 1]
-  );
-
-  return createTensor(output, input.dtype, [channels, outHeight, outWidth], 'upsample2d_output');
+  try {
+    await unifiedKernelWrapper(
+      'upsample2d', target, selectUpsample2DVariant(input.dtype === 'f16'),
+      [input, output],
+      {
+        channels, in_height: resolvedHeight, in_width: resolvedWidth,
+        out_height: outHeight, out_width: outWidth, scale,
+        _pad0: 0, _pad1: 0,
+      },
+      [Math.ceil(outSpatial / WORKGROUP_SIZES.DEFAULT), channels, 1]
+    );
+
+    return createTensor(output, input.dtype, [channels, outHeight, outWidth], 'upsample2d_output');
+  } catch (error) {
+    if (ownedOutput) {
+      releaseBuffer(ownedOutput);
+    }
+    throw error;
+  }
 }
 
 export async function runUpsample2D(input, options = {}) {

package/src/gpu/kernels/utils.js

@@ -137,21 +137,28 @@ export async function unifiedKernelWrapper(opName, target, variant, bindings, un
     });
   }
 
-  const bindGroup = device.createBindGroup({
-    label: `${opName}_bind_group`,
-    layout: pipeline.getBindGroupLayout(0),
-    entries: bindGroupEntries,
-  });
-
-  if (workgroups && typeof workgroups === 'object' && workgroups.indirectBuffer) {
-    const indirectOffset = workgroups.indirectOffset ?? 0;
-    if (recorder) {
-      recordDispatchIndirect(recorder, pipeline, bindGroup, workgroups.indirectBuffer, indirectOffset, opName);
+  try {
+    const bindGroup = device.createBindGroup({
+      label: `${opName}_bind_group`,
+      layout: pipeline.getBindGroupLayout(0),
+      entries: bindGroupEntries,
+    });
+
+    if (workgroups && typeof workgroups === 'object' && workgroups.indirectBuffer) {
+      const indirectOffset = workgroups.indirectOffset ?? 0;
+      if (recorder) {
+        recordDispatchIndirect(recorder, pipeline, bindGroup, workgroups.indirectBuffer, indirectOffset, opName);
+      } else {
+        dispatchIndirect(device, pipeline, bindGroup, workgroups.indirectBuffer, indirectOffset, opName);
+      }
     } else {
-      dispatchIndirect(device, pipeline, bindGroup, workgroups.indirectBuffer, indirectOffset, opName);
+      dispatchKernel(target, pipeline, bindGroup, workgroups, opName);
+    }
+  } catch (error) {
+    if (!recorder) {
+      uniformBuffer.destroy();
     }
-  } else {
-    dispatchKernel(target, pipeline, bindGroup, workgroups, opName);
+    throw error;
   }
 
   if (!recorder) {

package/src/gpu/partitioned-buffer-pool.js

@@ -11,10 +11,13 @@ export class PartitionedBufferPool {
   
   #expertPools;
 
+  #bufferOwners;
+
   
   constructor(partitions, schemaConfig = getRuntimeConfig().shared.bufferPool) {
     this.#sharedPool = new BufferPool(false, schemaConfig);
     this.#expertPools = new Map();
+    this.#bufferOwners = new WeakMap();
     for (const partition of partitions) {
       this.#expertPools.set(partition.id, new BufferPool(false, schemaConfig));
     }
@@ -28,12 +31,17 @@ export class PartitionedBufferPool {
     label
   ) {
     const pool = this.#expertPools.get(partitionId) || this.#sharedPool;
-    return pool.acquire(size, usage, label);
+    const buffer = pool.acquire(size, usage, label);
+    this.#bufferOwners.set(buffer, pool);
+    return buffer;
   }
 
   
   release(partitionId, buffer) {
-    const pool = this.#expertPools.get(partitionId) || this.#sharedPool;
+    const pool = this.#bufferOwners.get(buffer)
+      || this.#expertPools.get(partitionId)
+      || this.#sharedPool;
+    this.#bufferOwners.delete(buffer);
     pool.release(buffer);
   }
 

package/src/gpu/perf-guards.js

@@ -1,15 +1,8 @@
 
-
 import { log, trace } from '../debug/index.js';
+import { DEFAULT_PERF_GUARDS_CONFIG } from '../config/schema/debug.schema.js';
 
-// Initial config uses inline defaults; caller should configure via configurePerfGuards()
-let config = {
-  allowGPUReadback: true,
-  trackSubmitCount: false,
-  trackAllocations: false,
-  logExpensiveOps: false,
-  strictMode: false,
-};
+let config = { ...DEFAULT_PERF_GUARDS_CONFIG };
 
 
 let counters = {

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/gpu/weight-buffer.d.ts

@@ -110,6 +110,6 @@ export function getBuffer(weight: GPUBuffer | WeightBuffer | TensorLike): GPUBuf
 export function getLayout(weight: GPUBuffer | WeightBuffer | TensorLike): WeightLayout | null;
 
 /**
- * Get dtype from WeightBuffer, or null for raw GPUBuffer.
+ * Get dtype from WeightBuffer, tagged raw GPUBuffer, or TensorLike.
  */
 export function getWeightDtype(weight: GPUBuffer | WeightBuffer | TensorLike): WeightDtype | TensorLike['dtype'] | null;

package/src/gpu/weight-buffer.js

@@ -114,5 +114,5 @@ export function getLayout(weight) {
 export function getWeightDtype(weight) {
   if (isWeightBuffer(weight)) return weight.dtype;
   if (isTensorLike(weight)) return weight.dtype;
-  return null;
+  return getBufferDtype(weight);
 }

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';