@temporalio/workflow 1.10.1 → 1.10.2

package/src/cancellation-scope.ts

@@ -1,6 +1,9 @@
 import type { AsyncLocalStorage as ALS } from 'node:async_hooks';
 import { CancelledFailure, Duration, IllegalStateError } from '@temporalio/common';
+import { msOptionalToNumber } from '@temporalio/common/lib/time';
 import { untrackPromise } from './stack-helpers';
+import { getActivator } from './global-attributes';
+import { SdkFlags } from './flags';
 
 // AsyncLocalStorage is injected via vm module into global scope.
 // In case Workflow code is imported in Node.js context, replace with an empty class.
@@ -16,7 +19,7 @@ export interface CancellationScopeOptions {
   /**
    * Time in milliseconds before the scope cancellation is automatically requested
    */
-  timeout?: number;
+  timeout?: Duration;
 
   /**
    * If false, prevent outer cancellation from propagating to inner scopes, Activities, timers, and Triggers, defaults to true.
@@ -31,38 +34,56 @@ export interface CancellationScopeOptions {
 }
 
 /**
- * In the SDK, Workflows are represented internally by a tree of scopes where the `execute` function runs in the root scope.
- * Cancellation propagates from outer scopes to inner ones and is handled by catching {@link CancelledFailure}s
- * thrown by cancellable operations (see below).
+ * Cancellation Scopes provide the mechanic by which a Workflow may gracefully handle incoming requests for cancellation
+ * (e.g. in response to {@link WorkflowHandle.cancel} or through the UI or CLI), as well as request cancelation of
+ * cancellable operations it owns (e.g. Activities, Timers, Child Workflows, etc).
  *
- * Scopes are created using the `CancellationScope` constructor or the static helper methods
- * {@link cancellable}, {@link nonCancellable} and {@link withTimeout}.
+ * Cancellation Scopes form a tree, with the Workflow's main function running in the root scope of that tree.
+ * By default, cancellation propagates down from a parent scope to its children and its cancellable operations.
+ * A non-cancellable scope can receive cancellation requests, but is never effectively considered as cancelled,
+ * thus shieldding its children and cancellable operations from propagation of cancellation requests it receives.
  *
- * When a `CancellationScope` is cancelled, it will propagate cancellation any child scopes and any cancellable
- * operations created within it, such as:
+ * Scopes are created using the `CancellationScope` constructor or the static helper methods {@link cancellable},
+ * {@link nonCancellable} and {@link withTimeout}. `withTimeout` creates a scope that automatically cancels itself after
+ * some duration.
  *
- * - Activities
- * - Child Workflows
- * - Timers (created with the {@link sleep} function)
- * - {@link Trigger}s
- *
- * @example
+ * Cancellation of a cancellable scope results in all operations created directly in that scope to throw a
+ * {@link CancelledFailure} (either directly, or as the `cause` of an {@link ActivityFailure} or a
+ * {@link ChildWorkflowFailure}). Further attempt to create new cancellable scopes or cancellable operations within a
+ * scope that has already been cancelled will also immediately throw a {@link CancelledFailure} exception. It is however
+ * possible to create a non-cancellable scope at that point; this is often used to execute rollback or cleanup
+ * operations. For example:
  *
  * ```ts
- * await CancellationScope.cancellable(async () => {
- *   const promise = someActivity();
- *   CancellationScope.current().cancel(); // Cancels the activity
- *   await promise; // Throws `ActivityFailure` with `cause` set to `CancelledFailure`
- * });
+ * async function myWorkflow(...): Promise<void> {
+ *   try {
+ *     // This activity runs in the root cancellation scope. Therefore, a cancelation request on
+ *     // the Workflow execution (e.g. through the UI or CLI) automatically propagates to this
+ *     // activity. Assuming that the activity properly handle the cancellation request, then the
+ *     // call below will throw an `ActivityFailure` exception, with `cause` sets to an
+ *     // instance of `CancelledFailure`.
+ *     await someActivity();
+ *   } catch (e) {
+ *     if (isCancellation(e)) {
+ *       // Run cleanup activity in a non-cancellable scope
+ *       await CancellationScope.nonCancellable(async () => {
+ *         await cleanupActivity();
+ *       }
+ *     } else {
+ *       throw e;
+ *     }
+ *   }
+ * }
  * ```
  *
- * @example
+ * A cancellable scope may be programatically cancelled by calling {@link cancel|`scope.cancel()`}`. This may be used,
+ * for example, to explicitly request cancellation of an Activity or Child Workflow:
  *
  * ```ts
- * const scope = new CancellationScope();
- * const promise = scope.run(someActivity);
- * scope.cancel(); // Cancels the activity
- * await promise; // Throws `ActivityFailure` with `cause` set to `CancelledFailure`
+ * const cancellableActivityScope = new CancellationScope();
+ * const activityPromise = cancellableActivityScope.run(() => someActivity());
+ * cancellableActivityScope.cancel(); // Cancels the activity
+ * await activityPromise; // Throws `ActivityFailure` with `cause` set to `CancelledFailure`
  * ```
  */
 export class CancellationScope {
@@ -72,17 +93,28 @@ export class CancellationScope {
   protected readonly timeout?: number;
 
   /**
-   * If false, prevent outer cancellation from propagating to inner scopes, Activities, timers, and Triggers, defaults to true.
-   * (Scope still propagates CancelledFailure thrown from within)
+   * If false, then this scope will never be considered cancelled, even if a cancellation request is received (either
+   * directly by calling `scope.cancel()` or indirectly by cancelling a cancellable parent scope). This effectively
+   * shields the scope's children and cancellable operations from propagation of cancellation requests made on the
+   * non-cancellable scope.
+   *
+   * Note that the Promise returned by the `run` function of non-cancellable scope may still throw a `CancelledFailure`
+   * if such an exception is thrown from within that scope (e.g. by directly cancelling a cancellable child scope).
    */
   public readonly cancellable: boolean;
+
   /**
    * An optional CancellationScope (useful for running background tasks), defaults to {@link CancellationScope.current}()
    */
   public readonly parent?: CancellationScope;
 
   /**
-   * Rejected when scope cancellation is requested
+   * A Promise that throws when a cancellable scope receives a cancellation request, either directly
+   * (i.e. `scope.cancel()`), or indirectly (by cancelling a cancellable parent scope).
+   *
+   * Note that a non-cancellable scope may receive cancellation requests, resulting in the `cancelRequested` promise for
+   * that scope to throw, though the scope will not effectively get cancelled (i.e. `consideredCancelled` will still
+   * return `false`, and cancellation will not be propagated to child scopes and contained operations).
    */
   public readonly cancelRequested: Promise<never>;
 
@@ -94,12 +126,10 @@ export class CancellationScope {
   protected readonly reject: (reason?: any) => void;
 
   constructor(options?: CancellationScopeOptions) {
-    this.timeout = options?.timeout;
+    this.timeout = msOptionalToNumber(options?.timeout);
     this.cancellable = options?.cancellable ?? true;
     this.cancelRequested = new Promise((_, reject) => {
-      // Typescript does not understand that the Promise executor runs synchronously
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
+      // @ts-expect-error TSC doesn't understand that the Promise executor runs synchronously
       this.reject = (err) => {
         this.#cancelRequested = true;
         reject(err);
@@ -110,16 +140,36 @@ export class CancellationScope {
     untrackPromise(this.cancelRequested.catch(() => undefined));
     if (options?.parent !== NO_PARENT) {
       this.parent = options?.parent || CancellationScope.current();
-      this.#cancelRequested = this.parent.#cancelRequested;
-      this.parent.cancelRequested.catch((err) => {
-        this.reject(err);
-      });
+      if (
+        this.parent.cancellable ||
+        (this.parent.#cancelRequested &&
+          !getActivator().hasFlag(SdkFlags.NonCancellableScopesAreShieldedFromPropagation))
+      ) {
+        this.#cancelRequested = this.parent.#cancelRequested;
+        untrackPromise(
+          this.parent.cancelRequested.catch((err) => {
+            this.reject(err);
+          })
+        );
+      } else {
+        untrackPromise(
+          this.parent.cancelRequested.catch((err) => {
+            if (!getActivator().hasFlag(SdkFlags.NonCancellableScopesAreShieldedFromPropagation)) {
+              this.reject(err);
+            }
+          })
+        );
+      }
     }
   }
 
+  /**
+   * Whether the scope was effectively cancelled. A non-cancellable scope can never be considered cancelled.
+   */
   public get consideredCancelled(): boolean {
     return this.#cancelRequested && this.cancellable;
   }
+
   /**
    * Activate the scope as current and run  `fn`
    *
@@ -138,17 +188,31 @@ export class CancellationScope {
    * Could have been written as anonymous function, made into a method for improved stack traces.
    */
   protected async runInContext<T>(fn: () => Promise<T>): Promise<T> {
+    let timerScope: CancellationScope | undefined;
     if (this.timeout) {
+      timerScope = new CancellationScope();
       untrackPromise(
-        sleep(this.timeout).then(
-          () => this.cancel(),
-          () => {
-            // scope was already cancelled, ignore
-          }
-        )
+        timerScope
+          .run(() => sleep(this.timeout as number))
+          .then(
+            () => this.cancel(),
+            () => {
+              // scope was already cancelled, ignore
+            }
+          )
       );
     }
-    return await fn();
+    try {
+      return await fn();
+    } finally {
+      if (
+        timerScope &&
+        !timerScope.consideredCancelled &&
+        getActivator().hasFlag(SdkFlags.NonCancellableScopesAreShieldedFromPropagation)
+      ) {
+        timerScope.cancel();
+      }
+    }
   }
 
   /**
@@ -177,7 +241,7 @@ export class CancellationScope {
   }
 
   /** Alias to `new CancellationScope({ cancellable: true, timeout }).run(fn)` */
-  static withTimeout<T>(timeout: number, fn: () => Promise<T>): Promise<T> {
+  static withTimeout<T>(timeout: Duration, fn: () => Promise<T>): Promise<T> {
     return new this({ cancellable: true, timeout }).run(fn);
   }
 }

package/src/flags.ts

@@ -0,0 +1,30 @@
+export type SdkFlag = {
+  get id(): number;
+  get default(): boolean;
+};
+
+const flagsRegistry: Map<number, SdkFlag> = new Map();
+
+export const SdkFlags = {
+  /**
+   * This flag gates multiple fixes related to cancellation scopes and timers introduced in 1.10.2/1.11.0:
+   * - Cancellation of a non-cancellable scope no longer propagates to children scopes
+   *   (see https://github.com/temporalio/sdk-typescript/issues/1423).
+   * - CancellationScope.withTimeout(fn) now cancel the timer if `fn` completes before expiration
+   *   of the timeout, similar to how `condition(fn, timeout)` works.
+   * - Timers created using setTimeout can now be intercepted.
+   *
+   * @since Introduced in 1.10.2/1.11.0.
+   */
+  NonCancellableScopesAreShieldedFromPropagation: defineFlag(1, false),
+} as const;
+
+function defineFlag(id: number, def: boolean): SdkFlag {
+  const flag = { id, default: def };
+  flagsRegistry.set(id, flag);
+  return flag;
+}
+
+export function assertValidFlag(id: number): void {
+  if (!flagsRegistry.has(id)) throw new TypeError(`Unknown SDK flag: ${id}`);
+}

package/src/global-overrides.ts

@@ -0,0 +1,108 @@
+/**
+ * Overrides some global objects to make them deterministic.
+ *
+ * @module
+ */
+import { msToTs } from '@temporalio/common/lib/time';
+import { CancellationScope } from './cancellation-scope';
+import { DeterminismViolationError } from './errors';
+import { getActivator } from './global-attributes';
+import { SdkFlags } from './flags';
+import { sleep } from './workflow';
+import { untrackPromise } from './stack-helpers';
+
+const global = globalThis as any;
+const OriginalDate = globalThis.Date;
+
+export function overrideGlobals(): void {
+  // Mock any weak reference because GC is non-deterministic and the effect is observable from the Workflow.
+  // Workflow developer will get a meaningful exception if they try to use these.
+  global.WeakRef = function () {
+    throw new DeterminismViolationError('WeakRef cannot be used in Workflows because v8 GC is non-deterministic');
+  };
+  global.FinalizationRegistry = function () {
+    throw new DeterminismViolationError(
+      'FinalizationRegistry cannot be used in Workflows because v8 GC is non-deterministic'
+    );
+  };
+
+  global.Date = function (...args: unknown[]) {
+    if (args.length > 0) {
+      return new (OriginalDate as any)(...args);
+    }
+    return new OriginalDate(getActivator().now);
+  };
+
+  global.Date.now = function () {
+    return getActivator().now;
+  };
+
+  global.Date.parse = OriginalDate.parse.bind(OriginalDate);
+  global.Date.UTC = OriginalDate.UTC.bind(OriginalDate);
+
+  global.Date.prototype = OriginalDate.prototype;
+
+  const timeoutCancelationScopes = new Map<number, CancellationScope>();
+
+  /**
+   * @param ms sleep duration -  number of milliseconds. If given a negative number, value will be set to 1.
+   */
+  global.setTimeout = function (cb: (...args: any[]) => any, ms: number, ...args: any[]): number {
+    ms = Math.max(1, ms);
+    const activator = getActivator();
+    if (activator.hasFlag(SdkFlags.NonCancellableScopesAreShieldedFromPropagation)) {
+      // Capture the sequence number that sleep will allocate
+      const seq = activator.nextSeqs.timer;
+      const timerScope = new CancellationScope({ cancellable: true });
+      const sleepPromise = timerScope.run(() => sleep(ms));
+      sleepPromise.then(
+        () => {
+          timeoutCancelationScopes.delete(seq);
+          cb(...args);
+        },
+        () => {
+          timeoutCancelationScopes.delete(seq);
+        }
+      );
+      untrackPromise(sleepPromise);
+      timeoutCancelationScopes.set(seq, timerScope);
+      return seq;
+    } else {
+      const seq = activator.nextSeqs.timer++;
+      // Create a Promise for AsyncLocalStorage to be able to track this completion using promise hooks.
+      new Promise((resolve, reject) => {
+        activator.completions.timer.set(seq, { resolve, reject });
+        activator.pushCommand({
+          startTimer: {
+            seq,
+            startToFireTimeout: msToTs(ms),
+          },
+        });
+      }).then(
+        () => cb(...args),
+        () => undefined /* ignore cancellation */
+      );
+      return seq;
+    }
+  };
+
+  global.clearTimeout = function (handle: number): void {
+    const activator = getActivator();
+    const timerScope = timeoutCancelationScopes.get(handle);
+    if (timerScope) {
+      timeoutCancelationScopes.delete(handle);
+      timerScope.cancel();
+    } else {
+      activator.nextSeqs.timer++; // Shouldn't increase seq number, but that's the legacy behavior
+      activator.completions.timer.delete(handle);
+      activator.pushCommand({
+        cancelTimer: {
+          seq: handle,
+        },
+      });
+    }
+  };
+
+  // activator.random is mutable, don't hardcode its reference
+  Math.random = () => getActivator().random();
+}

package/src/interfaces.ts

@@ -479,3 +479,8 @@ export type SignalHandlerOptions = { description?: string };
  * A validator and description of an update handler.
  */
 export type UpdateHandlerOptions<Args extends any[]> = { validator?: UpdateValidator<Args>; description?: string };
+
+export interface ActivationCompletion {
+  commands: coresdk.workflow_commands.IWorkflowCommand[];
+  usedInternalFlags: number[];
+}

package/src/internals.ts

@@ -32,11 +32,13 @@ import {
   FileLocation,
   WorkflowInfo,
   WorkflowCreateOptionsInternal,
+  ActivationCompletion,
 } from './interfaces';
 import { type SinkCall } from './sinks';
 import { untrackPromise } from './stack-helpers';
 import pkg from './pkg';
 import { executeWithLifecycleLogging } from './logs';
+import { SdkFlag, assertValidFlag } from './flags';
 
 enum StartChildWorkflowExecutionFailedCause {
   START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED = 0,
@@ -304,12 +306,14 @@ export class Activator implements ActivationHandler {
   /**
    * Patches we know the status of for this workflow, as in {@link patched}
    */
-  public readonly knownPresentPatches = new Set<string>();
+  private readonly knownPresentPatches = new Set<string>();
 
   /**
    * Patches we sent to core {@link patched}
    */
-  public readonly sentPatches = new Set<string>();
+  private readonly sentPatches = new Set<string>();
+
+  private readonly knownFlags = new Set<number>();
 
   /**
    * Buffered sink calls per activation
@@ -394,10 +398,11 @@ export class Activator implements ActivationHandler {
     }
   }
 
-  getAndResetCommands(): coresdk.workflow_commands.IWorkflowCommand[] {
-    const commands = this.commands;
-    this.commands = [];
-    return commands;
+  concludeActivation(): ActivationCompletion {
+    return {
+      commands: this.commands.splice(0),
+      usedInternalFlags: [...this.knownFlags],
+    };
   }
 
   public async startWorkflowNextHandler({ args }: WorkflowExecuteInput): Promise<any> {
@@ -780,6 +785,41 @@ export class Activator implements ActivationHandler {
     this.knownPresentPatches.add(activation.patchId);
   }
 
+  public patchInternal(patchId: string, deprecated: boolean): boolean {
+    if (this.workflow === undefined) {
+      throw new IllegalStateError('Patches cannot be used before Workflow starts');
+    }
+    const usePatch = !this.info.unsafe.isReplaying || this.knownPresentPatches.has(patchId);
+    // Avoid sending commands for patches core already knows about.
+    // This optimization enables development of automatic patching tools.
+    if (usePatch && !this.sentPatches.has(patchId)) {
+      this.pushCommand({
+        setPatchMarker: { patchId, deprecated },
+      });
+      this.sentPatches.add(patchId);
+    }
+    return usePatch;
+  }
+
+  // Called early while handling an activation to register known flags
+  public addKnownFlags(flags: number[]): void {
+    for (const flag of flags) {
+      assertValidFlag(flag);
+      this.knownFlags.add(flag);
+    }
+  }
+
+  public hasFlag(flag: SdkFlag): boolean {
+    if (this.knownFlags.has(flag.id)) {
+      return true;
+    }
+    if (!this.info.unsafe.isReplaying && flag.default) {
+      this.knownFlags.add(flag.id);
+      return true;
+    }
+    return false;
+  }
+
   public removeFromCache(): void {
     throw new IllegalStateError('removeFromCache activation job should not reach workflow');
   }

package/src/trigger.ts

@@ -26,7 +26,7 @@ export class Trigger<T> implements PromiseLike<T> {
   constructor() {
     this.promise = new Promise<T>((resolve, reject) => {
       const scope = CancellationScope.current();
-      if (scope.consideredCancelled || scope.cancellable) {
+      if (scope.cancellable) {
         untrackPromise(scope.cancelRequested.catch(reject));
       }
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment

package/src/worker-interface.ts

@@ -4,11 +4,10 @@
  * @module
  */
 import { IllegalStateError } from '@temporalio/common';
-import { msToTs, tsToMs } from '@temporalio/common/lib/time';
+import { tsToMs } from '@temporalio/common/lib/time';
 import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { coresdk } from '@temporalio/proto';
 import { disableStorage } from './cancellation-scope';
-import { DeterminismViolationError } from './errors';
 import { WorkflowInterceptorsFactory } from './interceptors';
 import { WorkflowCreateOptionsInternal } from './interfaces';
 import { Activator } from './internals';
@@ -21,72 +20,6 @@ export { PromiseStackStore } from './internals';
 const global = globalThis as any;
 const OriginalDate = globalThis.Date;
 
-export function overrideGlobals(): void {
-  // Mock any weak reference because GC is non-deterministic and the effect is observable from the Workflow.
-  // Workflow developer will get a meaningful exception if they try to use these.
-  global.WeakRef = function () {
-    throw new DeterminismViolationError('WeakRef cannot be used in Workflows because v8 GC is non-deterministic');
-  };
-  global.FinalizationRegistry = function () {
-    throw new DeterminismViolationError(
-      'FinalizationRegistry cannot be used in Workflows because v8 GC is non-deterministic'
-    );
-  };
-
-  global.Date = function (...args: unknown[]) {
-    if (args.length > 0) {
-      return new (OriginalDate as any)(...args);
-    }
-    return new OriginalDate(getActivator().now);
-  };
-
-  global.Date.now = function () {
-    return getActivator().now;
-  };
-
-  global.Date.parse = OriginalDate.parse.bind(OriginalDate);
-  global.Date.UTC = OriginalDate.UTC.bind(OriginalDate);
-
-  global.Date.prototype = OriginalDate.prototype;
-
-  /**
-   * @param ms sleep duration -  number of milliseconds. If given a negative number, value will be set to 1.
-   */
-  global.setTimeout = function (cb: (...args: any[]) => any, ms: number, ...args: any[]): number {
-    const activator = getActivator();
-    ms = Math.max(1, ms);
-    const seq = activator.nextSeqs.timer++;
-    // Create a Promise for AsyncLocalStorage to be able to track this completion using promise hooks.
-    new Promise((resolve, reject) => {
-      activator.completions.timer.set(seq, { resolve, reject });
-      activator.pushCommand({
-        startTimer: {
-          seq,
-          startToFireTimeout: msToTs(ms),
-        },
-      });
-    }).then(
-      () => cb(...args),
-      () => undefined /* ignore cancellation */
-    );
-    return seq;
-  };
-
-  global.clearTimeout = function (handle: number): void {
-    const activator = getActivator();
-    activator.nextSeqs.timer++;
-    activator.completions.timer.delete(handle);
-    activator.pushCommand({
-      cancelTimer: {
-        seq: handle,
-      },
-    });
-  };
-
-  // activator.random is mutable, don't hardcode its reference
-  Math.random = () => getActivator().random();
-}
-
 /**
  * Initialize the isolate runtime.
  *
@@ -190,6 +123,7 @@ export function activate(activation: coresdk.workflow_activation.WorkflowActivat
         // timestamp will not be updated for activation that contain only queries
         activator.now = tsToMs(activation.timestamp);
       }
+      activator.addKnownFlags(activation.availableInternalFlags ?? []);
 
       // The Rust Core ensures that these activation fields are not null
       activator.mutateWorkflowInfo((info) => ({
@@ -249,11 +183,12 @@ export function concludeActivation(): coresdk.workflow_completion.IWorkflowActiv
   activator.rejectBufferedUpdates();
   const intercept = composeInterceptors(activator.interceptors.internals, 'concludeActivation', (input) => input);
   const { info } = activator;
-  const { commands } = intercept({ commands: activator.getAndResetCommands() });
+  const activationCompletion = activator.concludeActivation();
+  const { commands } = intercept({ commands: activationCompletion.commands });
 
   return {
     runId: info.runId,
-    successful: { commands },
+    successful: { ...activationCompletion, commands },
   };
 }
 

package/src/workflow.ts

@@ -3,7 +3,6 @@ import {
   ActivityOptions,
   compileRetryPolicy,
   extractWorkflowType,
-  IllegalStateError,
   LocalActivityOptions,
   mapToPayloads,
   QueryDefinition,
@@ -62,7 +61,7 @@ export function addDefaultWorkflowOptions<T extends Workflow>(
   const { args, workflowId, ...rest } = opts;
   return {
     workflowId: workflowId ?? uuid4(),
-    args: args ?? [],
+    args: (args ?? []) as unknown[],
     cancellationType: ChildWorkflowCancellationType.WAIT_CANCELLATION_COMPLETED,
     ...rest,
   };
@@ -987,7 +986,10 @@ export function uuid4(): string {
  * calls with the same ID, which means all such calls will always return the same value.
  */
 export function patched(patchId: string): boolean {
-  return patchInternal(patchId, false);
+  const activator = assertInWorkflowContext(
+    'Workflow.patch(...) and Workflow.deprecatePatch may only be used from a Workflow Execution.'
+  );
+  return activator.patchInternal(patchId, false);
 }
 
 /**
@@ -1008,29 +1010,10 @@ export function patched(patchId: string): boolean {
  * calls with the same ID, which means all such calls will always return the same value.
  */
 export function deprecatePatch(patchId: string): void {
-  patchInternal(patchId, true);
-}
-
-function patchInternal(patchId: string, deprecated: boolean): boolean {
   const activator = assertInWorkflowContext(
     'Workflow.patch(...) and Workflow.deprecatePatch may only be used from a Workflow Execution.'
   );
-  // Patch operation does not support interception at the moment, if it did,
-  // this would be the place to start the interception chain
-
-  if (activator.workflow === undefined) {
-    throw new IllegalStateError('Patches cannot be used before Workflow starts');
-  }
-  const usePatch = !activator.info.unsafe.isReplaying || activator.knownPresentPatches.has(patchId);
-  // Avoid sending commands for patches core already knows about.
-  // This optimization enables development of automatic patching tools.
-  if (usePatch && !activator.sentPatches.has(patchId)) {
-    activator.pushCommand({
-      setPatchMarker: { patchId, deprecated },
-    });
-    activator.sentPatches.add(patchId);
-  }
-  return usePatch;
+  activator.patchInternal(patchId, true);
 }
 
 /**