@@ -15,6 +15,14 @@ let brokerIdCounter = 0
 const FETCH_TIMEOUT_MS = 300000 // 5 minutes
 const BROKER_TIMEOUT_MS = 300000
 const MAX_STDOUT_CHARS = Number.parseInt(process.env.IVM_MAX_STDOUT_CHARS || '', 10) || 200000
+/**
+ * Task-mode timer bridges keep a Node `Timeout`, a Map entry, and an `ivm.Reference`
+ * per scheduled timer on the shared worker heap, outside the isolate's `memoryLimit`.
+ * These ceilings charge a timer flood to the offending execution instead of every
+ * co-tenant on the worker.
+ */
+const MAX_PENDING_TIMERS = 1000
+const MAX_ACTIVE_INTERVALS = 50
 const MAX_FETCH_OPTIONS_JSON_CHARS =
   Number.parseInt(process.env.IVM_MAX_FETCH_OPTIONS_JSON_CHARS || '', 10) || 256 * 1024
 
@@ -662,6 +670,7 @@ async function executeTask(request, executionId) {
   // sweep regardless of where execution throws.
   let nextTimerId = 1
   const timers = new Map()
+  let activeIntervals = 0
   const cleanupTimers = () => {
     for (const entry of timers.values()) {
       try {
@@ -673,6 +682,7 @@ async function executeTask(request, executionId) {
       } catch {}
     }
     timers.clear()
+    activeIntervals = 0
   }
 
   // Phase timings (ms). Populated inline during execution; returned in
@@ -757,7 +767,20 @@ async function executeTask(request, executionId) {
       return v
     }
 
+    // Thrown into the isolate, so the stack must not carry worker host frames.
+    const rejectTimer = (fnRef, message) => {
+      try {
+        fnRef.release()
+      } catch {}
+      const error = new RangeError(message)
+      error.stack = `RangeError: ${message}`
+      throw error
+    }
+
     const setTimeoutRef = new ivm.Reference((fnRef, msRef) => {
+      if (timers.size >= MAX_PENDING_TIMERS) {
+        rejectTimer(fnRef, `Too many pending timers (limit ${MAX_PENDING_TIMERS} per execution)`)
+      }
       const id = nextTimerId++
       const delay = Math.max(0, Math.min(Number(unwrapPrimitive(msRef)) || 0, timeoutMs))
       const nodeTimer = setTimeout(() => {
@@ -792,11 +815,21 @@ async function executeTask(request, executionId) {
         entry.fnRef.release()
       } catch {}
       timers.delete(key)
+      if (entry.recurring) activeIntervals--
     })
     releaseables.push(clearTimeoutRef)
     await jail.set('__clearTimeoutRef', clearTimeoutRef)
 
     const setIntervalRef = new ivm.Reference((fnRef, msRef) => {
+      if (timers.size >= MAX_PENDING_TIMERS) {
+        rejectTimer(fnRef, `Too many pending timers (limit ${MAX_PENDING_TIMERS} per execution)`)
+      }
+      if (activeIntervals >= MAX_ACTIVE_INTERVALS) {
+        rejectTimer(
+          fnRef,
+          `Too many active intervals (limit ${MAX_ACTIVE_INTERVALS} per execution)`
+        )
+      }
       const id = nextTimerId++
       const delay = Math.max(1, Math.min(Number(unwrapPrimitive(msRef)) || 1, timeoutMs))
       const nodeTimer = setInterval(() => {
@@ -810,6 +843,7 @@ async function executeTask(request, executionId) {
         }
       }, delay)
       timers.set(id, { nodeTimer, fnRef, recurring: true })
+      activeIntervals++
       return id
     })
     releaseables.push(setIntervalRef)
 
@@ -336,6 +336,34 @@ describe('isolated-vm scheduler', () => {
     expect(spawnMock).toHaveBeenCalledTimes(2)
   })
 
+  it('disposes the worker execution when the host timeout fires', async () => {
+    const sent: Array<{ type?: string; executionId?: number }> = []
+    const hungWorker = () => {
+      const proc = createBaseProc()
+      proc.send = (message: unknown) => {
+        sent.push(message as { type?: string; executionId?: number })
+        return true
+      }
+      setImmediate(() => proc.emit('message', { type: 'ready' }))
+      return proc
+    }
+    const { executeInIsolatedVM } = await loadExecutionModule({ spawns: [hungWorker] })
+
+    const result = await executeInIsolatedVM({
+      code: 'await new Promise(() => {})',
+      params: {},
+      envVars: {},
+      contextVariables: {},
+      timeoutMs: 10,
+      requestId: 'req-hung',
+    })
+
+    expect(result.termination).toBe('timeout')
+    const executed = sent.find((message) => message.type === 'execute')
+    expect(executed?.executionId).toBeDefined()
+    expect(sent).toContainEqual({ type: 'cancel', executionId: executed?.executionId })
+  })
+
   it('spawns workers with an allowlisted env, never the parent process.env', async () => {
     const ALLOWED_WORKER_ENV_KEYS = new Set([
       'PATH',
 
@@ -1309,6 +1309,13 @@ function dispatchToWorker(
 
   const timeout = setTimeout(() => {
     workerInfo.pendingExecutions.delete(execId)
+    // A never-settling promise escapes the isolate's own script timeout, so the worker
+    // would otherwise keep the isolate and its timers alive until the worker retires.
+    try {
+      workerInfo.process.send({ type: 'cancel', executionId: execId })
+    } catch (err) {
+      logger.warn('Failed to send timeout cancel to worker', { err, workerId: workerInfo.id })
+    }
     workerInfo.activeExecutions--
     totalActiveExecutions--
     ownerState.activeExecutions = Math.max(0, ownerState.activeExecutions - 1)
 
@@ -499,6 +499,43 @@ async function run() {
     assert.equal(next.result, 'still alive', next.error?.message)
   })
 
+  const runTask = (code: string) =>
+    executeInIsolatedVM({
+      code,
+      params: {},
+      envVars: {},
+      contextVariables: {},
+      timeoutMs: 10000,
+      requestId: `e2e-${generateRandomHex(4)}`,
+      ownerKey: 'e2e-owner',
+      task: {
+        id: 'e2e-timers',
+        bundles: [],
+        bootstrap: '',
+        brokers: [],
+        finalize: 'return new Uint8Array([1])',
+      },
+    })
+
+  await check('caps the timers a task may hold on the shared worker', async () => {
+    const timeouts = await runTask(
+      'const f = () => {}; for (let i = 0; i < 200000; i++) setTimeout(f, 60000)'
+    )
+    assert.match(timeouts.error?.message ?? '', /Too many pending timers/, timeouts.error?.message)
+    const intervals = await runTask(
+      'const f = () => {}; for (let i = 0; i < 200; i++) setInterval(f, 1000)'
+    )
+    assert.match(
+      intervals.error?.message ?? '',
+      /Too many active intervals/,
+      intervals.error?.message
+    )
+    const reused = await runTask(
+      'for (let round = 0; round < 3; round++) { const ids = []; for (let i = 0; i < 1000; i++) ids.push(setTimeout(() => {}, 60000)); ids.forEach(clearTimeout) }'
+    )
+    assert.equal(reused.error, undefined, reused.error?.message)
+  })
+
   await check('rejects a connection with the wrong token', async () => {
     const ws = await openSocket(probeHost, authFrame(generateRandomHex(32)))
     assert.equal(await closeCode(ws), 4401)