@simulatte/doppler 0.1.5 → 0.1.7

package/src/gpu/kernels/split_qkv.js

@@ -1,5 +1,5 @@
 
-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';
@@ -7,6 +7,9 @@ import { selectRuleValue } from './rule-registry.js';
 
 async function _splitQKV(target, qkvTensor, options) {
   const { numTokens, qSize, kSize, vSize, qTensor = null, kTensor = null, vTensor = null } = options;
+  const ownsQ = qTensor == null;
+  const ownsK = kTensor == null;
+  const ownsV = vTensor == null;
 
   const outputDtype = qkvTensor.dtype;
   const pipelineVariant = selectRuleValue('splitQkv', 'variant', { outputDtype });
@@ -18,18 +21,25 @@ async function _splitQKV(target, qkvTensor, options) {
 
   const totalElements = numTokens * (qSize + kSize + vSize);
 
-  await unifiedKernelWrapper(
-    'split_qkv', target, pipelineVariant,
-    [qkvTensor, qBuffer, kBuffer, vBuffer],
-    { num_tokens: numTokens, q_size: qSize, k_size: kSize, v_size: vSize },
-    Math.ceil(totalElements / WORKGROUP_SIZES.DEFAULT)
-  );
-
-  const Q = qTensor || createTensor(qBuffer, outputDtype, [numTokens, qSize], 'Q');
-  const K = kTensor || createTensor(kBuffer, outputDtype, [numTokens, kSize], 'K');
-  const V = vTensor || createTensor(vBuffer, outputDtype, [numTokens, vSize], 'V');
-
-  return { Q, K, V };
+  try {
+    await unifiedKernelWrapper(
+      'split_qkv', target, pipelineVariant,
+      [qkvTensor, qBuffer, kBuffer, vBuffer],
+      { num_tokens: numTokens, q_size: qSize, k_size: kSize, v_size: vSize },
+      Math.ceil(totalElements / WORKGROUP_SIZES.DEFAULT)
+    );
+
+    const Q = qTensor || createTensor(qBuffer, outputDtype, [numTokens, qSize], 'Q');
+    const K = kTensor || createTensor(kBuffer, outputDtype, [numTokens, kSize], 'K');
+    const V = vTensor || createTensor(vBuffer, outputDtype, [numTokens, vSize], 'V');
+
+    return { Q, K, V };
+  } catch (error) {
+    if (ownsQ) releaseBuffer(qBuffer);
+    if (ownsK) releaseBuffer(kBuffer);
+    if (ownsV) releaseBuffer(vBuffer);
+    throw error;
+  }
 }
 
 export async function runSplitQKV(qkvTensor, options) {

package/src/gpu/kernels/transpose.js

@@ -1,24 +1,45 @@
-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';
 
+function planTransposeDispatch(target, cols) {
+  const device = target?.device;
+  const maxPerDim = Number.isFinite(device?.limits?.maxComputeWorkgroupsPerDimension)
+    ? device.limits.maxComputeWorkgroupsPerDimension
+    : 65535;
+  const dispatchStride = Math.min(cols, maxPerDim * WORKGROUP_SIZES.DEFAULT);
+  return {
+    dispatchStride,
+    workgroups: [Math.ceil(dispatchStride / WORKGROUP_SIZES.DEFAULT), 1, 1],
+  };
+}
+
 async function _transpose(target, input, rows, cols, options = {}) {
   const { outputBuffer = null } = 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 },
-    Math.ceil((rows * cols) / WORKGROUP_SIZES.DEFAULT)
-  );
+  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

@@ -19,14 +19,15 @@ struct Uniforms {
 
 @compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
+    let dispatch_stride = max(u._pad0, 1u);
+    let linear_idx = gid.y * dispatch_stride + gid.x;
     let total = u.rows * u.cols;
-    if (idx >= total) {
+    if (linear_idx >= total) {
         return;
     }
-
-    let row = idx / u.cols;
-    let col = idx % u.cols;
+    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';
@@ -31,22 +31,31 @@ async function _upsample2d(target, input, options = {}) {
 
   const outHeight = resolvedHeight * scale;
   const outWidth = resolvedWidth * scale;
+  const outSpatial = outHeight * outWidth;
   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((channels * outHeight * outWidth) / WORKGROUP_SIZES.DEFAULT)
-  );
-
-  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/upsample2d.wgsl

@@ -19,19 +19,16 @@ struct Uniforms {
 
 @compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
     let out_spatial = u.out_height * u.out_width;
-    let total = u.channels * out_spatial;
-    if (idx >= total) {
+    let spatial_idx = gid.x;
+    let channel = gid.y;
+    if (spatial_idx >= out_spatial || channel >= u.channels) {
         return;
     }
-
-    let channel = idx / out_spatial;
-    let rem = idx - channel * out_spatial;
-    let out_y = rem / u.out_width;
-    let out_x = rem - out_y * u.out_width;
+    let out_y = spatial_idx / u.out_width;
+    let out_x = spatial_idx - out_y * u.out_width;
     let in_y = out_y / u.scale;
     let in_x = out_x / u.scale;
     let in_idx = (channel * u.in_height + in_y) * u.in_width + in_x;
-    output[idx] = input[in_idx];
+    output[channel * out_spatial + spatial_idx] = input[in_idx];
 }

package/src/gpu/kernels/upsample2d_f16.wgsl

@@ -23,19 +23,16 @@ struct Uniforms {
 
 @compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
     let out_spatial = u.out_height * u.out_width;
-    let total = u.channels * out_spatial;
-    if (idx >= total) {
+    let spatial_idx = gid.x;
+    let channel = gid.y;
+    if (spatial_idx >= out_spatial || channel >= u.channels) {
         return;
     }
-
-    let channel = idx / out_spatial;
-    let rem = idx - channel * out_spatial;
-    let out_y = rem / u.out_width;
-    let out_x = rem - out_y * u.out_width;
+    let out_y = spatial_idx / u.out_width;
+    let out_x = spatial_idx - out_y * u.out_width;
     let in_y = out_y / u.scale;
     let in_x = out_x / u.scale;
     let in_idx = (channel * u.in_height + in_y) * u.in_width + in_x;
-    output[idx] = input[in_idx];
+    output[channel * out_spatial + spatial_idx] = input[in_idx];
 }

package/src/gpu/kernels/utils.js

@@ -116,27 +116,49 @@ export async function unifiedKernelWrapper(opName, target, variant, bindings, un
       index = config.variantMetadata.outputBinding;
     }
 
+    const buffer = binding?.buffer || binding;
+    const isGpuBuffer = buffer && (
+      typeof GPUBuffer === 'undefined'
+        ? true
+        : buffer instanceof GPUBuffer
+    );
+    if (!isGpuBuffer) {
+      const bindingLabel = binding?.label ?? buffer?.label ?? 'unknown';
+      const bufferType = buffer === null ? 'null' : buffer === undefined ? 'undefined' : buffer.constructor?.name || typeof buffer;
+      throw new Error(
+        `Kernel "${opName}/${variant}" binding "${bindingConfig.name}" (index ${index}) requires a GPUBuffer ` +
+        `(label=${bindingLabel}, type=${bufferType}).`
+      );
+    }
+
     bindGroupEntries.push({
       binding: index,
-      resource: { buffer: binding?.buffer || binding }
+      resource: { buffer }
     });
   }
 
-  const bindGroup = device.createBindGroup({
-    label: `${opName}_bind_group`,
-    layout: pipeline.getBindGroupLayout(0),
-    entries: bindGroupEntries,
-  });
+  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);
+    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/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' };