@iworkflow/temporal 0.4.0 → 0.6.0

package/README.md

@@ -1,11 +1,19 @@
 # @iworkflow/temporal
 
-Temporal для `@iworkflow/core`. Peer: `@temporalio/{client,worker,workflow,activity}` ^1.24.
+Temporal для `@iworkflow/core`. Peer: `@temporalio/{client,common,worker,workflow,activity}` ^1.24.
+
+Модуль объявляет в своих зависимостях **все пять** peer, даже если сам импортирует не все: сборка
+сервера с `external: ["@temporalio/*"]` их не вкладывает, и без `@temporalio/common` под падает
+на старте с `Cannot find module`.
 
 - `temporalRuntime(workflowsPath, opts?).start(def)` — воркер на task queue `def.app`; `opts.workflowBundlePath` — готовый бандл прод-сборки.
 - `temporalClient(opts?)` — старт, сигнал, query по id.
+- `temporalActivities(activities)` — шаги порта для своего `Worker.create` (слив старой очереди, тестовый
+  воркер): `Failure` → `ApplicationFailure`, работают `heartbeat` и `stepAttempt`. Шаги без неё
+  в своём воркере `heartbeat`/`stepAttempt` не видят — с 0.6.0 рантайм шага ставится на время шага.
 - `@iworkflow/temporal/workflow` — только для входа песочницы модуля:
   `export const outreach = temporalFlow(flows.outreach, ["send-twice"])`.
 
-`opts` (`TemporalOptions`): `address`, `namespace`, `tls`, `apiKey` — источник токена, меняется каждые `apiKeyRenewMs`.
+`opts` (`TemporalOptions`): `address`, `namespace`, `tls`, `apiKey` — источник токена, меняется каждые `apiKeyRenewMs`;
+`plugins` — плагины SDK воркерам и клиенту; `temporalClient({ lazy: true })` — соединение при первом вызове.
 Без них — переменные `TEMPORAL_URL` (по умолчанию `127.0.0.1:17233`), `TEMPORAL_NAMESPACE`.

package/dist/connection.d.ts

@@ -1,4 +1,5 @@
-import type { TLSConfig } from "@temporalio/client";
+import type { ConnectionPlugin, TLSConfig } from "@temporalio/client";
+import type { WorkerPlugin } from "@temporalio/worker";
 /** Подключение к Temporal; не задано — TEMPORAL_URL и TEMPORAL_NAMESPACE из окружения. */
 export interface TemporalOptions {
     address?: string;
@@ -8,6 +9,8 @@ export interface TemporalOptions {
     /** Источник токена; соединение берёт свежий каждые apiKeyRenewMs (по умолчанию 60 с). */
     apiKey?: () => Promise<string>;
     apiKeyRenewMs?: number;
+    /** Плагины SDK (OpenTelemetry и т. п.) — воркерам и клиенту. */
+    plugins?: (ConnectionPlugin & WorkerPlugin)[];
 }
 export declare const address: (o: TemporalOptions) => string;
 export declare const namespace: (o: TemporalOptions) => string;

package/dist/index.d.ts

@@ -1,6 +1,11 @@
-import { type EngineClient, type EngineRuntime } from "@iworkflow/core";
+import { type Activity, type EngineClient, type EngineRuntime } from "@iworkflow/core";
 import { type TemporalOptions } from "./connection";
 export type { TemporalOptions };
+/**
+ * Шаги порта для своего Worker.create (слив старой очереди, тестовый воркер): Failure доезжает
+ * как ApplicationFailure, heartbeat и stepAttempt работают. temporalRuntime делает это сам.
+ */
+export declare function temporalActivities<T extends Record<string, Activity>>(activities: T): T;
 /**
  * workflowsPath — вход песочницы модуля: temporalFlow(...) на каждый процесс, имя экспорта = имя процесса.
  * workflowBundlePath — готовый бандл того же входа (прод-сборка); с ним воркер не собирает код сам.
@@ -8,4 +13,7 @@ export type { TemporalOptions };
 export declare function temporalRuntime(workflowsPath: string, opts?: TemporalOptions & {
     workflowBundlePath?: string;
 }): EngineRuntime;
-export declare function temporalClient(opts?: TemporalOptions): Promise<EngineClient>;
+/** lazy — соединение при первом вызове: модуль поднимается и без Temporal. */
+export declare function temporalClient(opts?: TemporalOptions & {
+    lazy?: boolean;
+}): Promise<EngineClient>;

package/dist/index.js

@@ -3,7 +3,9 @@ import { Client, Connection, WorkflowFailedError, WorkflowNotFoundError } from "
 import { Context } from "@temporalio/activity";
 import { NativeConnection, Worker } from "@temporalio/worker";
 import {
-  bindStepRuntime,
+  stepScope,
+  checkPriority,
+  DEFAULT_PRIORITY,
   exitSignal,
   FlowError as FlowError2
 } from "@iworkflow/core";
@@ -39,6 +41,7 @@ var connectOptions = async (o) => ({
 import {
   ActivityFailure,
   ApplicationFailure,
+  ApplicationFailureCategory,
   ChildWorkflowFailure,
   TerminatedFailure,
   TimeoutFailure,
@@ -74,13 +77,22 @@ function toTemporal(e, nonRetryable) {
       message: e.message,
       type: e.type,
       details: [e.details],
-      nonRetryable: nonRetryable || e.nonRetryable
+      nonRetryable: nonRetryable || e.nonRetryable,
+      ...e.retryAfterMs !== undefined ? { nextRetryDelay: Math.max(e.retryAfterMs, 1) } : {},
+      ...e.benign && !nonRetryable ? { category: ApplicationFailureCategory.BENIGN } : {}
     });
   if (isFlowError(e))
     return ApplicationFailure.create({ message: e.message, type: e.type ?? e.reason, details: [e.details], nonRetryable });
   return e;
 }
 
+// src/scope.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var alsScope = () => {
+  const als = new AsyncLocalStorage;
+  return { run: (rt, fn) => als.run(rt, fn), current: () => als.getStore() };
+};
+
 // src/index.ts
 var SIGNAL = "iwf.signal";
 var QUERY = "iwf.query";
@@ -99,29 +111,50 @@ var notFound = (id) => (e) => {
     throw new FlowError2(`процесса ${id} нет`, { reason: "not-found" });
   throw e;
 };
-var wrap = (h) => ({
+var wrap = (h, ready = async () => {}) => ({
   id: h.workflowId,
-  result: () => h.result().catch((e) => {
-    throw e instanceof WorkflowFailedError && cause(e.cause) || e;
-  }),
-  signal: (topic, value) => h.signal(SIGNAL, { topic, value }),
-  query: async (key) => await h.query(QUERY, key) ?? undefined,
+  result: async () => {
+    await ready();
+    return h.result().catch((e) => {
+      throw e instanceof WorkflowFailedError && cause(e.cause) || e;
+    });
+  },
+  signal: async (topic, value) => {
+    await ready();
+    await h.signal(SIGNAL, { topic, value });
+  },
+  query: async (key) => {
+    await ready();
+    return await h.query(QUERY, key) ?? undefined;
+  },
   async describe() {
+    await ready();
     const d = await h.describe().catch(notFound(h.workflowId));
     return { id: h.workflowId, status: STATUS[d.status.name] ?? "running", startedAt: d.startTime };
   },
-  terminate: async (reason) => void await h.terminate(reason).catch(notFound(h.workflowId))
+  async terminate(reason) {
+    await ready();
+    await h.terminate(reason).catch(notFound(h.workflowId));
+  }
 });
-var withFailures = (activities) => Object.fromEntries(Object.entries(activities).map(([name, fn]) => [
-  name,
-  async (...args) => {
-    try {
-      return await fn(...args);
-    } catch (e) {
-      throw toTemporal(e, false);
+var TEMPORAL_STEP = {
+  heartbeat: async (details) => Context.current().heartbeat(details),
+  lastHeartbeat: async () => Context.current().info.heartbeatDetails,
+  attempt: () => Context.current().info.attempt
+};
+function temporalActivities(activities) {
+  const scope = stepScope(alsScope);
+  return Object.fromEntries(Object.entries(activities).map(([name, fn]) => [
+    name,
+    async (...args) => {
+      try {
+        return await scope.run(TEMPORAL_STEP, () => fn(...args));
+      } catch (e) {
+        throw toTemporal(e, false);
+      }
     }
-  }
-]));
+  ]));
+}
 function temporalRuntime(workflowsPath, opts = {}) {
   let workers = [];
   let running = [];
@@ -137,10 +170,6 @@ function temporalRuntime(workflowsPath, opts = {}) {
       starting = true;
       exit.arm();
       stopping = false;
-      bindStepRuntime({
-        heartbeat: async (details) => Context.current().heartbeat(details),
-        lastHeartbeat: async () => Context.current().info.heartbeatDetails
-      });
       let c;
       try {
         c = conn = await NativeConnection.connect(await connectOptions(opts));
@@ -151,8 +180,8 @@ function temporalRuntime(workflowsPath, opts = {}) {
       }
       stopRenew = renewApiKey(opts, (t) => c.setApiKey(t));
       try {
-        const activities = withFailures(def.activities);
-        const base = { connection: c, namespace: namespace(opts) };
+        const activities = temporalActivities(def.activities);
+        const base = { connection: c, namespace: namespace(opts), ...opts.plugins ? { plugins: opts.plugins } : {} };
         const code = opts.workflowBundlePath ? { workflowBundle: { codePath: opts.workflowBundlePath } } : { workflowsPath };
         workers = [await Worker.create({ ...base, taskQueue: def.app, ...code, activities })];
         for (const [pool, limit] of Object.entries(def.pools ?? {}))
@@ -205,25 +234,57 @@ function temporalRuntime(workflowsPath, opts = {}) {
   };
 }
 async function temporalClient(opts = {}) {
-  const connection = await Connection.connect(await connectOptions(opts));
-  const stopRenew = renewApiKey(opts, (t) => connection.setApiKey(t));
+  let connection;
+  let stopRenew;
+  let ready = async () => {
+    return;
+  };
+  const plugins = opts.plugins ? { plugins: opts.plugins } : {};
+  if (opts.lazy) {
+    let token = "";
+    const apiKey = opts.apiKey;
+    let pending;
+    if (apiKey)
+      ready = async () => token || (token = await (pending ??= apiKey().finally(() => pending = undefined)));
+    connection = Connection.lazy({
+      ...await connectOptions({ ...opts, apiKey: undefined }),
+      ...apiKey ? { apiKey: () => token } : {},
+      ...plugins
+    });
+    stopRenew = renewApiKey(opts, (t) => token = t);
+  } else {
+    connection = await Connection.connect({ ...await connectOptions(opts), ...plugins });
+    stopRenew = renewApiKey(opts, (t) => connection.setApiKey(t));
+  }
   const client = new Client({ connection, namespace: namespace(opts) });
+  const startOptions = (target, args, o) => ({
+    taskQueue: target.app,
+    workflowId: o.id,
+    args,
+    ...o.timeoutMs ? { workflowExecutionTimeout: o.timeoutMs } : {},
+    priority: { priorityKey: checkPriority(o.priority) ?? DEFAULT_PRIORITY }
+  });
   return {
-    async start(target, args, opts) {
-      const h = await client.workflow.start(target.flow, {
-        taskQueue: target.app,
-        workflowId: opts.id,
-        args,
-        workflowIdConflictPolicy: "USE_EXISTING",
-        ...opts.timeoutMs ? { workflowExecutionTimeout: opts.timeoutMs } : {}
+    async start(target, args, o) {
+      await ready();
+      const h = await client.workflow.start(target.flow, { ...startOptions(target, args, o), workflowIdConflictPolicy: "USE_EXISTING" });
+      return wrap(h, ready);
+    },
+    async signalWithStart(target, args, o, topic, value) {
+      await ready();
+      const h = await client.workflow.signalWithStart(target.flow, {
+        ...startOptions(target, args, o),
+        signal: SIGNAL,
+        signalArgs: [{ topic, value }]
       });
-      return wrap(h);
+      return wrap(h, ready);
     },
-    handle: (id) => wrap(client.workflow.getHandle(id)),
+    handle: (id) => wrap(client.workflow.getHandle(id), ready),
     close: () => (stopRenew(), connection.close())
   };
 }
 export {
+  temporalActivities,
   temporalClient,
   temporalRuntime
 };

package/dist/scope.d.ts

@@ -0,0 +1,2 @@
+import type { StepScope } from "@iworkflow/core";
+export declare const alsScope: () => StepScope;

package/dist/workflow.js

@@ -15,12 +15,13 @@ import {
   TemporalFailure,
   workflowInfo
 } from "@temporalio/workflow";
-import { FlowError as FlowError2 } from "@iworkflow/core";
+import { checkPriority, DEFAULT_PRIORITY, FlowError as FlowError2 } from "@iworkflow/core";
 
 // src/failure.ts
 import {
   ActivityFailure,
   ApplicationFailure,
+  ApplicationFailureCategory,
   ChildWorkflowFailure,
   TerminatedFailure,
   TimeoutFailure,
@@ -56,7 +57,9 @@ function toTemporal(e, nonRetryable) {
       message: e.message,
       type: e.type,
       details: [e.details],
-      nonRetryable: nonRetryable || e.nonRetryable
+      nonRetryable: nonRetryable || e.nonRetryable,
+      ...e.retryAfterMs !== undefined ? { nextRetryDelay: Math.max(e.retryAfterMs, 1) } : {},
+      ...e.benign && !nonRetryable ? { category: ApplicationFailureCategory.BENIGN } : {}
     });
   if (isFlowError(e))
     return ApplicationFailure.create({ message: e.message, type: e.type ?? e.reason, details: [e.details], nonRetryable });
@@ -71,7 +74,8 @@ var queryDef = defineQuery(QUERY);
 var poolQueue = (app, pool) => `${app}@${pool}`;
 var proxies = new Map;
 function activitiesWith(opts = {}) {
-  const key = JSON.stringify(opts);
+  const priority = checkPriority(opts.priority) ?? workflowInfo().priority?.priorityKey;
+  const key = JSON.stringify({ ...opts, priority });
   let p = proxies.get(key);
   if (!p) {
     p = proxyActivities({
@@ -79,9 +83,10 @@ function activitiesWith(opts = {}) {
       startToCloseTimeout: opts.timeoutMs ?? 60000,
       ...opts.totalTimeoutMs ? { scheduleToCloseTimeout: opts.totalTimeoutMs } : {},
       ...opts.heartbeatTimeoutMs ? { heartbeatTimeout: opts.heartbeatTimeoutMs } : {},
+      ...priority ? { priority: { priorityKey: priority } } : {},
       retry: {
         maximumAttempts: opts.attempts ?? 3,
-        initialInterval: opts.retryIntervalMs ?? 200,
+        initialInterval: Math.max(opts.retryIntervalMs ?? 200, 1),
         backoffCoefficient: opts.backoff ?? 1,
         ...opts.maxRetryIntervalMs ? { maximumInterval: opts.maxRetryIntervalMs } : {},
         ...opts.nonRetryableTypes ? { nonRetryableErrorTypes: opts.nonRetryableTypes } : {}
@@ -116,6 +121,8 @@ function temporalFlow(flow, patches = []) {
       workflowId: info.workflowId,
       parentId: info.parent?.workflowId,
       startedAt: info.startTime,
+      priority: info.priority?.priorityKey || DEFAULT_PRIORITY,
+      now: async () => Date.now(),
       step: (name, stepArgs, opts) => activitiesWith(opts)[name](...stepArgs).catch(rethrow),
       child: (target, childArgs, opts) => executeChild(target.flow, childOptions(target.app, childArgs, opts)).catch(rethrow),
       async startChild(target, childArgs, opts) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iworkflow/temporal",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Temporal adapter for @iworkflow/core",
   "keywords": [
     "workflow",
@@ -41,7 +41,7 @@
     "prepack": "bun run build"
   },
   "dependencies": {
-    "@iworkflow/core": "^0.4.0"
+    "@iworkflow/core": "^0.6.0"
   },
   "peerDependencies": {
     "@temporalio/activity": "^1.24.0",

package/src/connection.ts

@@ -1,5 +1,6 @@
 // Подключение к Temporal: адрес, TLS, токен с заменой на месте — общее для воркера и клиента.
-import type { TLSConfig } from "@temporalio/client";
+import type { ConnectionPlugin, TLSConfig } from "@temporalio/client";
+import type { WorkerPlugin } from "@temporalio/worker";
 
 /** Подключение к Temporal; не задано — TEMPORAL_URL и TEMPORAL_NAMESPACE из окружения. */
 export interface TemporalOptions {
@@ -10,6 +11,8 @@ export interface TemporalOptions {
   /** Источник токена; соединение берёт свежий каждые apiKeyRenewMs (по умолчанию 60 с). */
   apiKey?: () => Promise<string>;
   apiKeyRenewMs?: number;
+  /** Плагины SDK (OpenTelemetry и т. п.) — воркерам и клиенту. */
+  plugins?: (ConnectionPlugin & WorkerPlugin)[];
 }
 
 export const address = (o: TemporalOptions) => o.address ?? process.env.TEMPORAL_URL ?? "127.0.0.1:17233";

package/src/failure.ts

@@ -2,6 +2,7 @@
 import {
   ActivityFailure,
   ApplicationFailure,
+  ApplicationFailureCategory,
   ChildWorkflowFailure,
   TerminatedFailure,
   TimeoutFailure,
@@ -41,6 +42,10 @@ export function toTemporal(e: unknown, nonRetryable: boolean): unknown {
       type: e.type,
       details: [e.details],
       nonRetryable: nonRetryable || e.nonRetryable,
+      // 0 сервер считает «не задано» и берёт паузу политики; 1 мс — «сразу», как у DBOS.
+      ...(e.retryAfterMs !== undefined ? { nextRetryDelay: Math.max(e.retryAfterMs, 1) } : {}),
+      // BENIGN — только отказу шага: отказ процесса целиком штатным не бывает.
+      ...(e.benign && !nonRetryable ? { category: ApplicationFailureCategory.BENIGN } : {}),
     });
   if (isFlowError(e))
     return ApplicationFailure.create({ message: e.message, type: e.type ?? e.reason, details: [e.details], nonRetryable });

package/src/index.ts

@@ -3,7 +3,10 @@ import { Client, Connection, WorkflowFailedError, WorkflowNotFoundError, type Wo
 import { Context } from "@temporalio/activity";
 import { NativeConnection, Worker } from "@temporalio/worker";
 import {
-  bindStepRuntime,
+  stepScope,
+  type StepRuntime,
+  checkPriority,
+  DEFAULT_PRIORITY,
   exitSignal,
   FlowError,
   type Activity,
@@ -11,10 +14,13 @@ import {
   type EngineClient,
   type EngineRuntime,
   type FlowHandle,
+  type FlowRef,
   type FlowStatus,
+  type StartOptions,
 } from "@iworkflow/core";
 import { address, connectOptions, namespace, renewApiKey, type TemporalOptions } from "./connection";
 import { cause, toTemporal } from "./failure";
+import { alsScope } from "./scope";
 
 export type { TemporalOptions };
 
@@ -38,35 +44,60 @@ const notFound = (id: string) => (e: unknown): never => {
   throw e;
 };
 
-const wrap = <T>(h: WorkflowHandle): FlowHandle<T> => ({
+/** ready — токен ленивого клиента: без него SDK уйдёт с пустым ключом. */
+const wrap = <T>(h: WorkflowHandle, ready: () => Promise<unknown> = async () => {}): FlowHandle<T> => ({
   id: h.workflowId,
-  result: () =>
-    h.result().catch((e) => {
+  result: async () => {
+    await ready();
+    return h.result().catch((e) => {
       throw (e instanceof WorkflowFailedError && cause(e.cause)) || e;
-    }),
-  signal: (topic, value) => h.signal(SIGNAL, { topic, value }),
-  query: async <V>(key: string) => ((await h.query(QUERY, key)) ?? undefined) as V | undefined,
+    });
+  },
+  signal: async (topic, value) => {
+    await ready();
+    await h.signal(SIGNAL, { topic, value });
+  },
+  query: async <V>(key: string) => {
+    await ready();
+    return ((await h.query(QUERY, key)) ?? undefined) as V | undefined;
+  },
   async describe() {
+    await ready();
     const d = await h.describe().catch(notFound(h.workflowId));
     return { id: h.workflowId, status: STATUS[d.status.name] ?? "running", startedAt: d.startTime };
   },
-  terminate: async (reason) => void (await h.terminate(reason).catch(notFound(h.workflowId))),
+  async terminate(reason) {
+    await ready();
+    await h.terminate(reason).catch(notFound(h.workflowId));
+  },
 });
 
-/** Шаги отдают Failure как ApplicationFailure: тип, детали и nonRetryable доезжают до процесса. */
-const withFailures = (activities: Record<string, Activity>) =>
-  Object.fromEntries(
+/** Рантайм шага Temporal: всё из контекста активности. */
+const TEMPORAL_STEP: StepRuntime = {
+  heartbeat: async (details) => Context.current().heartbeat(details),
+  lastHeartbeat: async () => Context.current().info.heartbeatDetails,
+  attempt: () => Context.current().info.attempt,
+};
+
+/**
+ * Шаги порта для своего Worker.create (слив старой очереди, тестовый воркер): Failure доезжает
+ * как ApplicationFailure, heartbeat и stepAttempt работают. temporalRuntime делает это сам.
+ */
+export function temporalActivities<T extends Record<string, Activity>>(activities: T): T {
+  const scope = stepScope(alsScope);
+  return Object.fromEntries(
     Object.entries(activities).map(([name, fn]) => [
       name,
       async (...args: unknown[]) => {
         try {
-          return await fn(...args);
+          return await scope.run(TEMPORAL_STEP, () => fn(...args));
         } catch (e) {
           throw toTemporal(e, false);
         }
       },
     ]),
-  );
+  ) as T;
+}
 
 /**
  * workflowsPath — вход песочницы модуля: temporalFlow(...) на каждый процесс, имя экспорта = имя процесса.
@@ -89,10 +120,6 @@ export function temporalRuntime(
       starting = true;
       exit.arm();
       stopping = false;
-      bindStepRuntime({
-        heartbeat: async (details) => Context.current().heartbeat(details),
-        lastHeartbeat: async () => Context.current().info.heartbeatDetails,
-      });
       let c: NativeConnection;
       try {
         c = conn = await NativeConnection.connect(await connectOptions(opts));
@@ -104,8 +131,8 @@ export function temporalRuntime(
       stopRenew = renewApiKey(opts, (t) => c.setApiKey(t));
       // Воркер не создался (нет бандла, namespace) — соединение и таймер токена закрываются.
       try {
-        const activities = withFailures(def.activities);
-        const base = { connection: c, namespace: namespace(opts) };
+        const activities = temporalActivities(def.activities);
+        const base = { connection: c, namespace: namespace(opts), ...(opts.plugins ? { plugins: opts.plugins } : {}) };
         const code = opts.workflowBundlePath ? { workflowBundle: { codePath: opts.workflowBundlePath } } : { workflowsPath };
         workers = [await Worker.create({ ...base, taskQueue: def.app, ...code, activities })];
         // Пул — своя очередь с пределом одновременных шагов в этом процессе.
@@ -162,22 +189,59 @@ export function temporalRuntime(
   };
 }
 
-export async function temporalClient(opts: TemporalOptions = {}): Promise<EngineClient> {
-  const connection = await Connection.connect(await connectOptions(opts));
-  const stopRenew = renewApiKey(opts, (t) => connection.setApiKey(t));
+/** lazy — соединение при первом вызове: модуль поднимается и без Temporal. */
+export async function temporalClient(opts: TemporalOptions & { lazy?: boolean } = {}): Promise<EngineClient> {
+  let connection: Connection;
+  let stopRenew: () => void;
+  let ready = async (): Promise<unknown> => undefined;
+  const plugins = opts.plugins ? { plugins: opts.plugins } : {};
+  if (opts.lazy) {
+    // Ни Temporal, ни источник токена не нужны для старта: ключ — функцией, берётся при первом вызове.
+    let token = "";
+    const apiKey = opts.apiKey;
+    // Неудача не залипает: следующий вызов спросит токен снова.
+    // Один запрос на всех ждущих; неудача не залипает: следующий вызов спросит снова.
+    let pending: Promise<string> | undefined;
+    if (apiKey)
+      ready = async () =>
+        token ||
+        (token = await (pending ??= apiKey().finally(() => (pending = undefined))));
+    connection = Connection.lazy({
+      ...(await connectOptions({ ...opts, apiKey: undefined })),
+      ...(apiKey ? { apiKey: () => token } : {}),
+      ...plugins,
+    });
+    stopRenew = renewApiKey(opts, (t) => (token = t));
+  } else {
+    connection = await Connection.connect({ ...(await connectOptions(opts)), ...plugins });
+    stopRenew = renewApiKey(opts, (t) => connection.setApiKey(t));
+  }
+  // Плагины — у соединения: оно само передаёт их клиенту.
   const client = new Client({ connection, namespace: namespace(opts) });
+  const startOptions = (target: FlowRef, args: unknown[], o: StartOptions) => ({
+    taskQueue: target.app,
+    workflowId: o.id,
+    args,
+    ...(o.timeoutMs ? { workflowExecutionTimeout: o.timeoutMs } : {}),
+    // Явно и по умолчанию: ctx.priority и очередь видят одно и то же, как у DBOS.
+    priority: { priorityKey: checkPriority(o.priority) ?? DEFAULT_PRIORITY },
+  });
   return {
-    async start(target, args, opts) {
-      const h = await client.workflow.start(target.flow, {
-        taskQueue: target.app,
-        workflowId: opts.id,
-        args,
-        workflowIdConflictPolicy: "USE_EXISTING",
-        ...(opts.timeoutMs ? { workflowExecutionTimeout: opts.timeoutMs } : {}),
+    async start(target, args, o) {
+      await ready();
+      const h = await client.workflow.start(target.flow, { ...startOptions(target, args, o), workflowIdConflictPolicy: "USE_EXISTING" });
+      return wrap(h, ready);
+    },
+    async signalWithStart(target, args, o, topic, value) {
+      await ready();
+      const h = await client.workflow.signalWithStart(target.flow, {
+        ...startOptions(target, args, o),
+        signal: SIGNAL,
+        signalArgs: [{ topic, value }],
       });
-      return wrap(h);
+      return wrap(h, ready);
     },
-    handle: (id) => wrap(client.workflow.getHandle(id)),
+    handle: (id) => wrap(client.workflow.getHandle(id), ready),
     close: () => (stopRenew(), connection.close()),
   };
 }

package/src/scope.ts

@@ -0,0 +1,8 @@
+// Область шага на AsyncLocalStorage: stepScope ядра берёт её у первого адаптера процесса.
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { StepRuntime, StepScope } from "@iworkflow/core";
+
+export const alsScope = (): StepScope => {
+  const als = new AsyncLocalStorage<StepRuntime>();
+  return { run: (rt, fn) => als.run(rt, fn), current: () => als.getStore() };
+};

package/src/workflow.ts

@@ -18,7 +18,7 @@ import {
   workflowInfo,
 } from "@temporalio/workflow";
 
-import { FlowError, type ChildOptions, type Flow, type FlowContext, type StepOptions } from "@iworkflow/core";
+import { checkPriority, DEFAULT_PRIORITY, FlowError, type ChildOptions, type Flow, type FlowContext, type StepOptions } from "@iworkflow/core";
 import { fromTemporal, toTemporal } from "./failure";
 
 export const SIGNAL = "iwf.signal";
@@ -32,7 +32,9 @@ export const poolQueue = (app: string, pool: string) => `${app}@${pool}`;
 const proxies = new Map<string, Record<string, (...a: unknown[]) => Promise<unknown>>>();
 
 function activitiesWith(opts: StepOptions = {}) {
-  const key = JSON.stringify(opts);
+  // Шаг без своего приоритета — с приоритетом процесса, как у Temporal по умолчанию.
+  const priority = checkPriority(opts.priority) ?? workflowInfo().priority?.priorityKey;
+  const key = JSON.stringify({ ...opts, priority });
   let p = proxies.get(key);
   if (!p) {
     p = proxyActivities({
@@ -40,9 +42,11 @@ function activitiesWith(opts: StepOptions = {}) {
       startToCloseTimeout: opts.timeoutMs ?? 60_000,
       ...(opts.totalTimeoutMs ? { scheduleToCloseTimeout: opts.totalTimeoutMs } : {}),
       ...(opts.heartbeatTimeoutMs ? { heartbeatTimeout: opts.heartbeatTimeoutMs } : {}),
+      ...(priority ? { priority: { priorityKey: priority } } : {}),
       retry: {
         maximumAttempts: opts.attempts ?? 3,
-        initialInterval: opts.retryIntervalMs ?? 200,
+        // 0 Temporal не принимает (ValueError — вечный повтор задачи процесса): 1 мс — «сразу», как у DBOS.
+        initialInterval: Math.max(opts.retryIntervalMs ?? 200, 1),
         backoffCoefficient: opts.backoff ?? 1,
         ...(opts.maxRetryIntervalMs ? { maximumInterval: opts.maxRetryIntervalMs } : {}),
         ...(opts.nonRetryableTypes ? { nonRetryableErrorTypes: opts.nonRetryableTypes } : {}),
@@ -83,6 +87,9 @@ export function temporalFlow(flow: Flow, patches: string[] = []) {
       workflowId: info.workflowId,
       parentId: info.parent?.workflowId,
       startedAt: info.startTime,
+      priority: info.priority?.priorityKey || DEFAULT_PRIORITY,
+      // Date.now() в песочнице Temporal детерминирован: время задачи процесса.
+      now: async () => Date.now(),
       step: (name, stepArgs, opts) => activitiesWith(opts)[name]!(...stepArgs).catch(rethrow) as Promise<never>,
       child: (target, childArgs, opts) =>
         executeChild(target.flow, childOptions(target.app, childArgs, opts)).catch(rethrow) as Promise<never>,