@qwen-code/qwen-code 0.20.0 → 0.20.1-nightly.20260724.7d17c44a3

package/chunks/chunk-NABLFI57.js

@@ -0,0 +1,82 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  createDebugLogger
+} from "./chunk-OQB4EXO4.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/hooks/registerSkillHooks.ts
+init_esbuild_shims();
+var debugLogger = createDebugLogger("SKILL_HOOKS");
+function registerSkillHooks(sessionHooksManager, sessionId, skill) {
+  if (!skill.hooks) {
+    debugLogger.debug(`Skill '${skill.name}' has no hooks to register`);
+    return 0;
+  }
+  const hooksSettings = skill.hooks;
+  let registeredCount = 0;
+  for (const eventName of Object.keys(hooksSettings)) {
+    const matchers = hooksSettings[eventName];
+    if (!matchers) continue;
+    for (const matcher of matchers) {
+      const matcherPattern = matcher.matcher || "";
+      for (const hook of matcher.hooks) {
+        if (hook.type === "function" /* Function */) {
+          debugLogger.debug(
+            "Skipping function hook from skill (not supported in frontmatter)"
+          );
+          continue;
+        }
+        const hookConfig = prepareHookConfig(
+          hook,
+          skill.skillRoot
+        );
+        sessionHooksManager.addSessionHook(
+          sessionId,
+          eventName,
+          matcherPattern,
+          hookConfig,
+          { skillRoot: skill.skillRoot }
+        );
+        registeredCount++;
+        debugLogger.debug(
+          `Registered hook for ${eventName} with matcher '${matcherPattern}' from skill '${skill.name}'`
+        );
+      }
+    }
+  }
+  if (registeredCount > 0) {
+    debugLogger.info(
+      `Registered ${registeredCount} hooks from skill '${skill.name}'`
+    );
+  }
+  return registeredCount;
+}
+__name(registerSkillHooks, "registerSkillHooks");
+function prepareHookConfig(hook, skillRoot) {
+  if (hook.type === "command" && skillRoot) {
+    return {
+      ...hook,
+      env: {
+        ...hook.env,
+        QWEN_SKILL_ROOT: skillRoot
+      }
+    };
+  }
+  return hook;
+}
+__name(prepareHookConfig, "prepareHookConfig");
+
+export {
+  registerSkillHooks
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/chunk-NBQDBANR.js

@@ -0,0 +1,411 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  createDebugLogger
+} from "./chunk-OQB4EXO4.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/runtimeFetchOptions.ts
+init_esbuild_shims();
+var debugLogger = createDebugLogger("RUNTIME_FETCH");
+var undiciModule;
+var undiciModulePromise;
+async function loadUndici() {
+  undiciModulePromise ??= import("./undici-3FJYTMOF.js").then((mod) => {
+    const keys = Object.keys(mod);
+    if (keys.length === 1 && keys[0] === "default") {
+      return mod.default;
+    }
+    return mod;
+  });
+  return undiciModulePromise;
+}
+__name(loadUndici, "loadUndici");
+async function preloadRuntimeFetchModule() {
+  if (undiciModule) return;
+  undiciModule = await loadUndici();
+}
+__name(preloadRuntimeFetchModule, "preloadRuntimeFetchModule");
+function requireUndici() {
+  if (!undiciModule) {
+    throw new Error(
+      "undici is not loaded yet; await preloadRuntimeFetchModule() before building runtime fetch options or dispatchers"
+    );
+  }
+  return undiciModule;
+}
+__name(requireUndici, "requireUndici");
+function isTlsVerificationDisabled() {
+  const flag = process.env["QWEN_TLS_INSECURE"];
+  if (flag !== void 0 && /^(1|true|yes|on)$/i.test(flag.trim())) {
+    return true;
+  }
+  return process.env["NODE_TLS_REJECT_UNAUTHORIZED"] === "0";
+}
+__name(isTlsVerificationDisabled, "isTlsVerificationDisabled");
+function detectRuntime() {
+  if (typeof process !== "undefined" && process.versions?.["bun"]) {
+    return "bun";
+  }
+  if (typeof process !== "undefined" && process.versions?.node) {
+    return "node";
+  }
+  return "unknown";
+}
+__name(detectRuntime, "detectRuntime");
+function buildRuntimeFetchOptions(sdkType, proxyUrl) {
+  const runtime = detectRuntime();
+  switch (runtime) {
+    case "bun": {
+      if (sdkType === "openai") {
+        return {
+          fetchOptions: {
+            timeout: false
+          }
+        };
+      } else {
+        const bunFetch = /* @__PURE__ */ __name(async (input, init) => {
+          const bunFetchOptions = {
+            ...init,
+            // @ts-expect-error - Bun-specific timeout option
+            timeout: false
+          };
+          return fetch(input, bunFetchOptions);
+        }, "bunFetch");
+        return {
+          fetch: bunFetch
+        };
+      }
+    }
+    case "node": {
+      return buildFetchOptionsWithDispatcher(sdkType, proxyUrl);
+    }
+    default: {
+      return buildFetchOptionsWithDispatcher(sdkType, proxyUrl);
+    }
+  }
+}
+__name(buildRuntimeFetchOptions, "buildRuntimeFetchOptions");
+var dispatcherCache = /* @__PURE__ */ new Map();
+var proxyFailureCounts = /* @__PURE__ */ new Map();
+var NO_DISPATCHER_FALLBACK = {
+  openai: void 0,
+  anthropic: {}
+};
+function getOrCreateSharedDispatcher(proxyUrl, insecure = isTlsVerificationDisabled()) {
+  const cacheKey = insecure ? `${proxyUrl}#insecure` : proxyUrl;
+  const cached = dispatcherCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const { EnvHttpProxyAgent } = requireUndici();
+  const dispatcher = new EnvHttpProxyAgent({
+    httpProxy: proxyUrl,
+    httpsProxy: proxyUrl,
+    headersTimeout: 0,
+    bodyTimeout: 0,
+    keepAliveTimeout: 6e4,
+    // EnvHttpProxyAgent can dispatch either directly or through a proxy.
+    // `connect` covers a direct NO_PROXY connection, `requestTls` covers the
+    // origin through a proxy, and `proxyTls` covers an HTTPS proxy itself.
+    ...insecure ? {
+      connect: { rejectUnauthorized: false },
+      requestTls: { rejectUnauthorized: false },
+      proxyTls: { rejectUnauthorized: false }
+    } : {}
+  });
+  dispatcherCache.set(cacheKey, dispatcher);
+  return dispatcher;
+}
+__name(getOrCreateSharedDispatcher, "getOrCreateSharedDispatcher");
+function extractHostnameFromProxyUrl(proxyUrl) {
+  try {
+    const url = new URL(proxyUrl);
+    if (url.hostname) {
+      return url.port ? `${url.hostname}:${url.port}` : url.hostname;
+    }
+  } catch {
+  }
+  const match = proxyUrl.match(/@([^:/\s]+)(:\d+)?/);
+  return match ? match[1] + (match[2] ?? "") : redactProxyCredentials(proxyUrl);
+}
+__name(extractHostnameFromProxyUrl, "extractHostnameFromProxyUrl");
+function hasPlausibleProxyPort(host) {
+  const portMatch = host.match(/:(\d{1,5})$/);
+  if (!portMatch) {
+    return false;
+  }
+  const port = Number(portMatch[1]);
+  return port >= 80 && port <= 65535;
+}
+__name(hasPlausibleProxyPort, "hasPlausibleProxyPort");
+function hasLocalOrProxyLikeHost(host) {
+  const hostWithoutPort = host.replace(/:\d{1,5}$/, "").toLowerCase();
+  if (hostWithoutPort === "localhost") {
+    return true;
+  }
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostWithoutPort)) {
+    return true;
+  }
+  return hostWithoutPort.split(/[.-]/).some((label) => /^(proxy|gateway|gw|squid)\d*$/.test(label));
+}
+__name(hasLocalOrProxyLikeHost, "hasLocalOrProxyLikeHost");
+function hasNetworkErrorContext(message, offset) {
+  const context = message.slice(Math.max(0, offset - 80), offset).toLowerCase();
+  return /\b(connect|dispatcher|econnrefused|econnreset|enotfound|etimedout|proxy|tunnel)\b/.test(
+    context
+  );
+}
+__name(hasNetworkErrorContext, "hasNetworkErrorContext");
+function shouldRedactTokenOnlyCredential(host, message, offset) {
+  return hasPlausibleProxyPort(host) && (hasLocalOrProxyLikeHost(host) || hasNetworkErrorContext(message, offset));
+}
+__name(shouldRedactTokenOnlyCredential, "shouldRedactTokenOnlyCredential");
+function redactProxyCredentials(message) {
+  let result = message.replace(/\/\/[^/\s]*@/g, "//<redacted>@");
+  result = result.replace(
+    /(^|[\s([=:])([^\s/@()[\]=]+@[^@\s/()[\]=]+)/g,
+    (match, prefix, candidate, offset, message2) => {
+      const atIndex = candidate.indexOf("@");
+      const userInfo = candidate.slice(0, atIndex);
+      const host = candidate.slice(atIndex + 1);
+      if (!userInfo.includes(":") && !shouldRedactTokenOnlyCredential(host, message2, offset)) {
+        return match;
+      }
+      return `${prefix}<redacted>@${host}`;
+    }
+  );
+  return result;
+}
+__name(redactProxyCredentials, "redactProxyCredentials");
+function redactProxyError(error) {
+  return redactProxyErrorValue(error, /* @__PURE__ */ new WeakMap());
+}
+__name(redactProxyError, "redactProxyError");
+function redactProxyErrorValue(error, seen) {
+  if (typeof error === "string") {
+    return redactProxyCredentials(error);
+  }
+  if (!error || typeof error !== "object") {
+    return error;
+  }
+  if (seen.has(error)) {
+    return seen.get(error);
+  }
+  const errorRecord = error;
+  const needsClone = shouldCloneForRedaction(error, errorRecord);
+  const redactedMessage = typeof errorRecord.message === "string" ? redactProxyCredentials(errorRecord.message) : void 0;
+  const redactedStack = typeof errorRecord.stack === "string" ? redactProxyCredentials(errorRecord.stack) : void 0;
+  let redactedCause = errorRecord.cause;
+  let redactedErrors = errorRecord.errors;
+  if (needsClone) {
+    const clone = Object.create(Object.getPrototypeOf(error));
+    seen.set(error, clone);
+    if (errorRecord.cause !== void 0) {
+      redactedCause = redactProxyErrorValue(errorRecord.cause, seen);
+    }
+    if (errorRecord.errors !== void 0) {
+      redactedErrors = redactProxyErrorCollection(errorRecord.errors, seen);
+    }
+    cloneErrorWithRedactedFields(
+      error,
+      clone,
+      redactedMessage,
+      redactedStack,
+      redactedCause,
+      redactedErrors
+    );
+    return clone;
+  }
+  seen.set(error, error);
+  try {
+    if (redactedMessage !== void 0) {
+      errorRecord.message = redactedMessage;
+    }
+    if (redactedStack !== void 0) {
+      errorRecord.stack = redactedStack;
+    }
+    if (errorRecord.cause !== void 0) {
+      redactedCause = redactProxyErrorValue(errorRecord.cause, seen);
+      errorRecord.cause = redactedCause;
+    }
+    if (errorRecord.errors !== void 0) {
+      redactedErrors = redactProxyErrorCollection(errorRecord.errors, seen);
+      errorRecord.errors = redactedErrors;
+    }
+    return error;
+  } catch {
+    const clone = Object.create(Object.getPrototypeOf(error));
+    seen.set(error, clone);
+    if (errorRecord.cause !== void 0) {
+      redactedCause = redactProxyErrorValue(errorRecord.cause, seen);
+    }
+    if (errorRecord.errors !== void 0) {
+      redactedErrors = redactProxyErrorCollection(errorRecord.errors, seen);
+    }
+    cloneErrorWithRedactedFields(
+      error,
+      clone,
+      redactedMessage,
+      redactedStack,
+      redactedCause,
+      redactedErrors
+    );
+    return clone;
+  }
+}
+__name(redactProxyErrorValue, "redactProxyErrorValue");
+function redactProxyErrorCollection(errors, seen) {
+  if (!Array.isArray(errors)) {
+    return redactProxyErrorValue(errors, seen);
+  }
+  if (seen.has(errors)) {
+    return seen.get(errors);
+  }
+  const redactedErrors = [];
+  seen.set(errors, redactedErrors);
+  for (const error of errors) {
+    redactedErrors.push(redactProxyErrorValue(error, seen));
+  }
+  return redactedErrors;
+}
+__name(redactProxyErrorCollection, "redactProxyErrorCollection");
+function shouldCloneForRedaction(error, errorRecord) {
+  return typeof errorRecord.message === "string" && !canAssignProperty(error, "message") || typeof errorRecord.stack === "string" && !canAssignProperty(error, "stack") || errorRecord.cause !== void 0 && !canAssignProperty(error, "cause") || errorRecord.errors !== void 0 && !canAssignProperty(error, "errors");
+}
+__name(shouldCloneForRedaction, "shouldCloneForRedaction");
+function canAssignProperty(target, key) {
+  let current = target;
+  while (current) {
+    const descriptor = Object.getOwnPropertyDescriptor(current, key);
+    if (descriptor) {
+      if ("writable" in descriptor) {
+        return descriptor.writable === true;
+      }
+      return typeof descriptor.set === "function";
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return Object.isExtensible(target);
+}
+__name(canAssignProperty, "canAssignProperty");
+function cloneErrorWithRedactedFields(error, clone, redactedMessage, redactedStack, redactedCause, redactedErrors) {
+  const copiedKeys = /* @__PURE__ */ new Set();
+  for (const key of Reflect.ownKeys(error)) {
+    const descriptor = Object.getOwnPropertyDescriptor(error, key);
+    if (!descriptor) {
+      continue;
+    }
+    copiedKeys.add(key);
+    const updatedDescriptor = getRedactedPropertyDescriptor(
+      key,
+      descriptor,
+      redactedMessage,
+      redactedStack,
+      redactedCause,
+      redactedErrors
+    );
+    try {
+      Object.defineProperty(clone, key, updatedDescriptor);
+    } catch {
+    }
+  }
+  defineMissingRedactedValue(clone, copiedKeys, "message", redactedMessage);
+  defineMissingRedactedValue(clone, copiedKeys, "stack", redactedStack);
+  defineMissingRedactedValue(clone, copiedKeys, "cause", redactedCause);
+  defineMissingRedactedValue(clone, copiedKeys, "errors", redactedErrors);
+}
+__name(cloneErrorWithRedactedFields, "cloneErrorWithRedactedFields");
+function getRedactedPropertyDescriptor(key, descriptor, redactedMessage, redactedStack, redactedCause, redactedErrors) {
+  const redactedValue = key === "message" ? redactedMessage : key === "stack" ? redactedStack : key === "cause" ? redactedCause : key === "errors" ? redactedErrors : void 0;
+  if (redactedValue === void 0) {
+    return { ...descriptor };
+  }
+  if ("value" in descriptor) {
+    return { ...descriptor, value: redactedValue };
+  }
+  return {
+    configurable: descriptor.configurable,
+    enumerable: descriptor.enumerable,
+    value: redactedValue,
+    writable: true
+  };
+}
+__name(getRedactedPropertyDescriptor, "getRedactedPropertyDescriptor");
+function defineMissingRedactedValue(target, copiedKeys, key, value) {
+  if (value === void 0 || copiedKeys.has(key)) {
+    return;
+  }
+  try {
+    Object.defineProperty(target, key, {
+      configurable: true,
+      enumerable: false,
+      value,
+      writable: true
+    });
+  } catch {
+  }
+}
+__name(defineMissingRedactedValue, "defineMissingRedactedValue");
+function recordProxyFailure(hostname) {
+  const failureCount = (proxyFailureCounts.get(hostname) ?? 0) + 1;
+  proxyFailureCounts.set(hostname, failureCount);
+  return failureCount;
+}
+__name(recordProxyFailure, "recordProxyFailure");
+function buildFetchOptionsWithDispatcher(sdkType, proxyUrl) {
+  const insecure = isTlsVerificationDisabled();
+  const { Agent, fetch: undiciFetch } = requireUndici();
+  if (!proxyUrl) {
+    const NO_PROXY_KEY = insecure ? "__no_proxy__#insecure" : "__no_proxy__";
+    let dispatcher = dispatcherCache.get(NO_PROXY_KEY);
+    if (!dispatcher) {
+      dispatcher = new Agent({
+        headersTimeout: 0,
+        bodyTimeout: 0,
+        keepAliveTimeout: 6e4,
+        // For a direct (non-proxy) Agent, `connect` options flow straight to
+        // the TLS connector, so this disables upstream cert verification.
+        ...insecure ? { connect: { rejectUnauthorized: false } } : {}
+      });
+      dispatcherCache.set(NO_PROXY_KEY, dispatcher);
+    }
+    return { fetchOptions: { dispatcher }, fetch: undiciFetch };
+  }
+  try {
+    const dispatcher = getOrCreateSharedDispatcher(proxyUrl, insecure);
+    return { fetchOptions: { dispatcher }, fetch: undiciFetch };
+  } catch (error) {
+    const hostname = extractHostnameFromProxyUrl(proxyUrl);
+    const failureCount = recordProxyFailure(hostname);
+    const failureLabel = failureCount === 1 ? "first failure" : `failure #${failureCount}`;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const redactedMessage = redactProxyCredentials(errorMessage);
+    const logMessage = `Failed to create proxy dispatcher for ${hostname} (${failureLabel}), falling back to direct connection: ${redactedMessage}`;
+    debugLogger.warn(logMessage);
+    console.error(`[RUNTIME_FETCH] ${logMessage}`);
+    return NO_DISPATCHER_FALLBACK[sdkType];
+  }
+}
+__name(buildFetchOptionsWithDispatcher, "buildFetchOptionsWithDispatcher");
+
+export {
+  loadUndici,
+  preloadRuntimeFetchModule,
+  isTlsVerificationDisabled,
+  detectRuntime,
+  buildRuntimeFetchOptions,
+  getOrCreateSharedDispatcher,
+  redactProxyCredentials,
+  redactProxyError
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-EAUYY7SS.js → chunk-NOAAFNTJ.js}

@@ -4,7 +4,7 @@ import {
   matches,
   nextFireTime,
   parseCron
-} from "./chunk-XU457J4V.js";
+} from "./chunk-IRH27ZC2.js";
 import {
   humanReadableCron
 } from "./chunk-VDDGDZMA.js";
@@ -19,15 +19,15 @@ import {
   taskHasLegacyCondition,
   taskHasLegacyRunMode,
   updateCronTasks
-} from "./chunk-EIAK6Q2B.js";
+} from "./chunk-C3VHAXP2.js";
 import {
   ToolNames
-} from "./chunk-OP4MOGXF.js";
+} from "./chunk-P5RRUHL7.js";
 import {
   Storage,
   createDebugLogger,
   getProjectHash
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -191,6 +191,16 @@ function computeJitter(id, cronExpr, recurring) {
   return 0;
 }
 __name(computeJitter, "computeJitter");
+function cronJitterWindowMinutes(jitterMs) {
+  return Math.ceil(Math.abs(jitterMs) / 6e4);
+}
+__name(cronJitterWindowMinutes, "cronJitterWindowMinutes");
+function isCronSlotVisibleToTick(slotMinuteMs, currentMs, jitterMs) {
+  const currentMinute = new Date(currentMs);
+  currentMinute.setSeconds(0, 0);
+  return Math.abs(currentMinute.getTime() - slotMinuteMs) <= cronJitterWindowMinutes(jitterMs) * 6e4;
+}
+__name(isCronSlotVisibleToTick, "isCronSlotVisibleToTick");
 var generateId = generateCronTaskId;
 function clampWakeupSeconds(delaySeconds) {
   if (!Number.isFinite(delaySeconds)) return WAKEUP_DEFAULT_SECONDS;
@@ -285,6 +295,10 @@ var CronScheduler = class {
   // the live job away (or clear its pendingRemoval guard) as if it had
   // been deleted on disk.
   pendingAdd = /* @__PURE__ */ new Set();
+  // Durable one-shots this continuously-running scheduler loaded while it was
+  // eligible to fire them. Cleared on stop so a later enable still treats
+  // genuinely overdue work as missed.
+  armedDurableOneShots = /* @__PURE__ */ new Set();
   // Ids of legacy tasks (a pre-removal `isolated` task with a `condition`
   // precondition) already reported as skipped, so the fail-closed remediation
   // breadcrumb is logged once per task rather than on every file reload.
@@ -462,6 +476,9 @@ var CronScheduler = class {
     this.pendingAdd.add(job.id);
     try {
       await addCronTask(this.projectRoot, jobToDurableTask(job));
+      if (!job.recurring && this.durableEnabled && this.#shouldFireDurable(job)) {
+        this.armedDurableOneShots.add(job.id);
+      }
     } catch (error) {
       this.jobs.delete(job.id);
       throw error;
@@ -491,6 +508,7 @@ var CronScheduler = class {
         throw error;
       }
     }
+    this.armedDurableOneShots.delete(id);
     return true;
   }
   /**
@@ -656,6 +674,8 @@ var CronScheduler = class {
         const anchor = t.recurring ? t.lastFiredAt ?? t.createdAt : t.createdAt;
         const nextFire = computeNextFireMs(t.cron, anchor, jitter);
         if (nextFire === null || nextFire >= now) continue;
+        if (!t.recurring && this.timer !== null && this.armedDurableOneShots.has(t.id) && isCronSlotVisibleToTick(nextFire - jitter, now, jitter))
+          continue;
         if (!t.recurring) {
           missedOneShots.push(t);
         } else if (now - t.createdAt >= this.recurringMaxAgeMs) {
@@ -671,6 +691,7 @@ var CronScheduler = class {
       }
       for (const t of [...missedOneShots, ...finalTasks]) {
         this.pendingRemoval.add(t.id);
+        this.armedDurableOneShots.delete(t.id);
         this.jobs.delete(t.id);
       }
     }
@@ -679,6 +700,7 @@ var CronScheduler = class {
     for (const job of this.jobs.values()) {
       if (job.durable && !diskIds.has(job.id)) {
         this.jobs.delete(job.id);
+        this.armedDurableOneShots.delete(job.id);
       }
     }
     for (const id of this.pendingRemoval) {
@@ -700,6 +722,11 @@ var CronScheduler = class {
         job.lastFiredAt = Math.max(existing.lastFiredAt, job.lastFiredAt ?? 0);
       }
       this.jobs.set(task.id, job);
+      if (!task.recurring && this.#shouldFireDurable(job)) {
+        this.armedDurableOneShots.add(task.id);
+      } else {
+        this.armedDurableOneShots.delete(task.id);
+      }
       if (!existing) durableJobCount++;
     }
     if (catchUpIds.length > 0) {
@@ -762,7 +789,8 @@ var CronScheduler = class {
           onFire({
             ...carrier,
             prompt: buildMissedCronNotification(runnable),
-            missed: true
+            missed: true,
+            delivery: void 0
           });
           this.removeMissedFromDisk(runnable.map((t) => t.id));
         }
@@ -966,6 +994,7 @@ var CronScheduler = class {
     }
     this.wakeupChainStartedAt = null;
     this.onFire = null;
+    this.armedDurableOneShots.clear();
     if (this.durableEnabled) {
       this.durableGeneration++;
       if (this.isOwner && this.projectRoot && this.sessionId) {
@@ -1067,7 +1096,10 @@ var CronScheduler = class {
       }
     }
     if (this.projectRoot && (firedAt.size > 0 || removedIds.length > 0)) {
-      for (const id of removedIds) this.pendingRemoval.add(id);
+      for (const id of removedIds) {
+        this.pendingRemoval.add(id);
+        this.armedDurableOneShots.delete(id);
+      }
       const removed = new Set(removedIds);
       const guarded = [...firedAt.keys()];
       this.markFirePersistPending(guarded);
@@ -1108,8 +1140,7 @@ var CronScheduler = class {
    * and 'none' otherwise.
    */
   processJob(job, currentDate, currentMs) {
-    const absJitter = Math.abs(job.jitterMs);
-    const windowMinutes = Math.ceil(absJitter / 6e4);
+    const windowMinutes = cronJitterWindowMinutes(job.jitterMs);
     const nowMinuteStart = new Date(currentDate);
     nowMinuteStart.setSeconds(0, 0);
     const nowMinuteMs = nowMinuteStart.getTime();
@@ -1220,7 +1251,8 @@ function durableTaskToJob(task, recurringMaxAgeMs, existing) {
     lastFiredAt: task.lastFiredAt ?? void 0,
     jitterMs,
     durable: true,
-    ...task.sessionId ? { boundSessionId: task.sessionId } : {}
+    ...task.sessionId ? { boundSessionId: task.sessionId } : {},
+    ...task.delivery && task.sessionId ? { delivery: task.delivery } : {}
   };
 }
 __name(durableTaskToJob, "durableTaskToJob");
@@ -1232,7 +1264,8 @@ function jobToDurableTask(job) {
     recurring: job.recurring,
     createdAt: job.createdAt,
     lastFiredAt: job.lastFiredAt ?? null,
-    ...job.boundSessionId ? { sessionId: job.boundSessionId } : {}
+    ...job.boundSessionId ? { sessionId: job.boundSessionId } : {},
+    ...job.delivery ? { delivery: job.delivery } : {}
   };
 }
 __name(jobToDurableTask, "jobToDurableTask");