@iworkflow/temporal 0.3.0 → 0.5.0

package/README.md

@@ -7,5 +7,6 @@ Temporal для `@iworkflow/core`. Peer: `@temporalio/{client,worker,workflow,ac
 - `@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

@@ -0,0 +1,23 @@
+import type { ConnectionPlugin, TLSConfig } from "@temporalio/client";
+import type { WorkerPlugin } from "@temporalio/worker";
+/** Подключение к Temporal; не задано — TEMPORAL_URL и TEMPORAL_NAMESPACE из окружения. */
+export interface TemporalOptions {
+    address?: string;
+    namespace?: string;
+    /** TLSConfig SDK (serverNameOverride, свой CA, mTLS). С apiKey SDK включает TLS сам — без TLS только `false`. */
+    tls?: boolean | TLSConfig;
+    /** Источник токена; соединение берёт свежий каждые 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;
+/** Токен меняется на месте: иначе воркер однажды молча перестанет брать задачи. */
+export declare function renewApiKey(o: TemporalOptions, set: (token: string) => unknown): () => void;
+export declare const connectOptions: (o: TemporalOptions) => Promise<{
+    address: string;
+    tls?: boolean | TLSConfig | undefined;
+    apiKey?: string | undefined;
+}>;

package/dist/failure.d.ts

@@ -0,0 +1,7 @@
+import { FlowError } from "@iworkflow/core";
+/** Отказ шага, дочернего процесса или процесса целиком — FlowError; прочее (отмена) — как есть. */
+export declare function fromTemporal(e: unknown): unknown;
+/** Причина отказа процесса или шага — FlowError; undefined — причина не наша (отмена и т. п.). */
+export declare function cause(c: Error | undefined, exhausted?: boolean): FlowError | undefined;
+/** Отказ из кода порта — ApplicationFailure: обычная ошибка в песочнице не роняет процесс, а повторяет задачу. */
+export declare function toTemporal(e: unknown, nonRetryable: boolean): unknown;

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { type EngineClient, type EngineRuntime } from "@iworkflow/core";
+import { type TemporalOptions } from "./connection";
+export type { TemporalOptions };
+/**
+ * workflowsPath — вход песочницы модуля: temporalFlow(...) на каждый процесс, имя экспорта = имя процесса.
+ * workflowBundlePath — готовый бандл того же входа (прод-сборка); с ним воркер не собирает код сам.
+ */
+export declare function temporalRuntime(workflowsPath: string, opts?: TemporalOptions & {
+    workflowBundlePath?: string;
+}): EngineRuntime;
+/** lazy — соединение при первом вызове: модуль поднимается и без Temporal. */
+export declare function temporalClient(opts?: TemporalOptions & {
+    lazy?: boolean;
+}): Promise<EngineClient>;

package/dist/index.js

@@ -0,0 +1,277 @@
+// src/index.ts
+import { Client, Connection, WorkflowFailedError, WorkflowNotFoundError } from "@temporalio/client";
+import { Context } from "@temporalio/activity";
+import { NativeConnection, Worker } from "@temporalio/worker";
+import {
+  bindStepRuntime,
+  checkPriority,
+  DEFAULT_PRIORITY,
+  exitSignal,
+  FlowError as FlowError2
+} from "@iworkflow/core";
+
+// src/connection.ts
+var address = (o) => o.address ?? process.env.TEMPORAL_URL ?? "127.0.0.1:17233";
+var namespace = (o) => o.namespace ?? process.env.TEMPORAL_NAMESPACE ?? "default";
+function renewApiKey(o, set) {
+  if (!o.apiKey)
+    return () => {};
+  const apiKey = o.apiKey;
+  let busy = false;
+  let stopped = false;
+  const timer = setInterval(() => {
+    if (busy)
+      return;
+    busy = true;
+    apiKey().then((t) => stopped ? undefined : set(t)).catch((e) => stopped || console.error("токен Temporal не обновлён:", e)).finally(() => busy = false);
+  }, o.apiKeyRenewMs ?? 60000);
+  timer.unref?.();
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+}
+var connectOptions = async (o) => ({
+  address: address(o),
+  ...o.tls !== undefined ? { tls: o.tls } : {},
+  ...o.apiKey ? { apiKey: await o.apiKey() } : {}
+});
+
+// src/failure.ts
+import {
+  ActivityFailure,
+  ApplicationFailure,
+  ChildWorkflowFailure,
+  TerminatedFailure,
+  TimeoutFailure,
+  WorkflowExecutionAlreadyStartedError
+} from "@temporalio/common";
+import { Failure, FlowError, isFlowError } from "@iworkflow/core";
+function fromTemporal(e) {
+  if (e instanceof WorkflowExecutionAlreadyStartedError)
+    return new FlowError(`процесс ${e.workflowId} уже есть`, { reason: "already-started" });
+  if (e instanceof ActivityFailure) {
+    const exhausted = e.retryState === "MAXIMUM_ATTEMPTS_REACHED";
+    const f = cause(e.cause, exhausted);
+    if (f && e.retryState === "TIMEOUT")
+      return new FlowError(f.message, { reason: "timeout", type: f.type, details: f.details });
+    return f ?? e;
+  }
+  if (e instanceof ChildWorkflowFailure)
+    return cause(e.cause, false) ?? e;
+  return e;
+}
+function cause(c, exhausted = false) {
+  if (c instanceof TimeoutFailure)
+    return new FlowError(c.message || "срок вышел", { reason: "timeout", exhausted });
+  if (c instanceof TerminatedFailure)
+    return new FlowError(c.message || "процесс прерван", { reason: "terminated" });
+  if (c instanceof ApplicationFailure)
+    return new FlowError(c.message, { reason: "failed", type: c.type ?? undefined, details: c.details?.[0], exhausted });
+  return;
+}
+function toTemporal(e, nonRetryable) {
+  if (e instanceof Failure)
+    return ApplicationFailure.create({
+      message: e.message,
+      type: e.type,
+      details: [e.details],
+      nonRetryable: nonRetryable || e.nonRetryable,
+      ...e.retryAfterMs !== undefined ? { nextRetryDelay: Math.max(e.retryAfterMs, 1) } : {}
+    });
+  if (isFlowError(e))
+    return ApplicationFailure.create({ message: e.message, type: e.type ?? e.reason, details: [e.details], nonRetryable });
+  return e;
+}
+
+// src/index.ts
+var SIGNAL = "iwf.signal";
+var QUERY = "iwf.query";
+var poolQueue = (app, pool) => `${app}@${pool}`;
+var STATUS = {
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "terminated",
+  TERMINATED: "terminated",
+  TIMED_OUT: "timed-out",
+  CONTINUED_AS_NEW: "running"
+};
+var notFound = (id) => (e) => {
+  if (e instanceof WorkflowNotFoundError)
+    throw new FlowError2(`процесса ${id} нет`, { reason: "not-found" });
+  throw e;
+};
+var wrap = (h, ready = async () => {}) => ({
+  id: h.workflowId,
+  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 };
+  },
+  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);
+    }
+  }
+]));
+function temporalRuntime(workflowsPath, opts = {}) {
+  let workers = [];
+  let running = [];
+  let conn;
+  let starting = false;
+  let stopping = false;
+  const exit = exitSignal();
+  let stopRenew = () => {};
+  return {
+    async start(def) {
+      if (starting)
+        throw new Error("воркер уже запущен");
+      starting = true;
+      exit.arm();
+      stopping = false;
+      bindStepRuntime({
+        heartbeat: async (details) => Context.current().heartbeat(details),
+        lastHeartbeat: async () => Context.current().info.heartbeatDetails,
+        attempt: () => Context.current().info.attempt
+      });
+      let c;
+      try {
+        c = conn = await NativeConnection.connect(await connectOptions(opts));
+      } catch (e) {
+        starting = false;
+        exit.reject(e);
+        throw e;
+      }
+      stopRenew = renewApiKey(opts, (t) => c.setApiKey(t));
+      try {
+        const activities = withFailures(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 ?? {}))
+          workers.push(await Worker.create({
+            ...base,
+            taskQueue: poolQueue(def.app, pool),
+            activities,
+            maxConcurrentActivityTaskExecutions: limit
+          }));
+      } catch (e) {
+        await Promise.allSettled(workers.map(async (w) => {
+          const r = w.run();
+          w.shutdown();
+          await r;
+        }));
+        stopRenew();
+        await c.close().catch(() => {});
+        conn = undefined;
+        workers = [];
+        starting = false;
+        exit.reject(e);
+        throw e;
+      }
+      running = workers.map((w) => w.run());
+      Promise.all(running).then(() => stopping || exit.resolve(), () => {});
+      for (const r of running)
+        r.catch((e) => stopping || exit.reject(e));
+    },
+    done: () => exit.promise(),
+    async stop() {
+      stopping = true;
+      for (const w of workers)
+        if (w.getState() === "RUNNING")
+          w.shutdown();
+      const done = await Promise.allSettled(running);
+      stopRenew();
+      try {
+        await conn?.close();
+      } finally {
+        conn = undefined;
+        workers = [];
+        running = [];
+        starting = false;
+        exit.resolve();
+      }
+      const failed = done.find((r) => r.status === "rejected");
+      if (failed)
+        throw failed.reason;
+    }
+  };
+}
+async function temporalClient(opts = {}) {
+  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, 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, ready);
+    },
+    handle: (id) => wrap(client.workflow.getHandle(id), ready),
+    close: () => (stopRenew(), connection.close())
+  };
+}
+export {
+  temporalClient,
+  temporalRuntime
+};

package/dist/workflow.d.ts

@@ -0,0 +1,7 @@
+import { type Flow } from "@iworkflow/core";
+export declare const SIGNAL = "iwf.signal";
+export declare const QUERY = "iwf.query";
+/** Очередь пула шагов модуля; воркер пула поднимает temporalRuntime. */
+export declare const poolQueue: (app: string, pool: string) => string;
+/** patches — как AppDefinition.patches: необъявленный id — ошибка, как у DBOS. */
+export declare function temporalFlow(flow: Flow, patches?: string[]): (...args: unknown[]) => Promise<unknown>;

package/dist/workflow.js

@@ -0,0 +1,165 @@
+// src/workflow.ts
+import {
+  condition,
+  defineQuery,
+  defineSignal,
+  deprecatePatch,
+  executeChild,
+  getExternalWorkflowHandle,
+  ParentClosePolicy,
+  patched,
+  proxyActivities,
+  setHandler,
+  sleep,
+  startChild,
+  TemporalFailure,
+  workflowInfo
+} from "@temporalio/workflow";
+import { checkPriority, DEFAULT_PRIORITY, FlowError as FlowError2 } from "@iworkflow/core";
+
+// src/failure.ts
+import {
+  ActivityFailure,
+  ApplicationFailure,
+  ChildWorkflowFailure,
+  TerminatedFailure,
+  TimeoutFailure,
+  WorkflowExecutionAlreadyStartedError
+} from "@temporalio/common";
+import { Failure, FlowError, isFlowError } from "@iworkflow/core";
+function fromTemporal(e) {
+  if (e instanceof WorkflowExecutionAlreadyStartedError)
+    return new FlowError(`процесс ${e.workflowId} уже есть`, { reason: "already-started" });
+  if (e instanceof ActivityFailure) {
+    const exhausted = e.retryState === "MAXIMUM_ATTEMPTS_REACHED";
+    const f = cause(e.cause, exhausted);
+    if (f && e.retryState === "TIMEOUT")
+      return new FlowError(f.message, { reason: "timeout", type: f.type, details: f.details });
+    return f ?? e;
+  }
+  if (e instanceof ChildWorkflowFailure)
+    return cause(e.cause, false) ?? e;
+  return e;
+}
+function cause(c, exhausted = false) {
+  if (c instanceof TimeoutFailure)
+    return new FlowError(c.message || "срок вышел", { reason: "timeout", exhausted });
+  if (c instanceof TerminatedFailure)
+    return new FlowError(c.message || "процесс прерван", { reason: "terminated" });
+  if (c instanceof ApplicationFailure)
+    return new FlowError(c.message, { reason: "failed", type: c.type ?? undefined, details: c.details?.[0], exhausted });
+  return;
+}
+function toTemporal(e, nonRetryable) {
+  if (e instanceof Failure)
+    return ApplicationFailure.create({
+      message: e.message,
+      type: e.type,
+      details: [e.details],
+      nonRetryable: nonRetryable || e.nonRetryable,
+      ...e.retryAfterMs !== undefined ? { nextRetryDelay: Math.max(e.retryAfterMs, 1) } : {}
+    });
+  if (isFlowError(e))
+    return ApplicationFailure.create({ message: e.message, type: e.type ?? e.reason, details: [e.details], nonRetryable });
+  return e;
+}
+
+// src/workflow.ts
+var SIGNAL = "iwf.signal";
+var QUERY = "iwf.query";
+var signalDef = defineSignal(SIGNAL);
+var queryDef = defineQuery(QUERY);
+var poolQueue = (app, pool) => `${app}@${pool}`;
+var proxies = new Map;
+function activitiesWith(opts = {}) {
+  const priority = checkPriority(opts.priority) ?? workflowInfo().priority?.priorityKey;
+  const key = JSON.stringify({ ...opts, priority });
+  let p = proxies.get(key);
+  if (!p) {
+    p = proxyActivities({
+      ...opts.pool ? { taskQueue: poolQueue(workflowInfo().taskQueue, opts.pool) } : {},
+      startToCloseTimeout: opts.timeoutMs ?? 60000,
+      ...opts.totalTimeoutMs ? { scheduleToCloseTimeout: opts.totalTimeoutMs } : {},
+      ...opts.heartbeatTimeoutMs ? { heartbeatTimeout: opts.heartbeatTimeoutMs } : {},
+      ...priority ? { priority: { priorityKey: priority } } : {},
+      retry: {
+        maximumAttempts: opts.attempts ?? 3,
+        initialInterval: Math.max(opts.retryIntervalMs ?? 200, 1),
+        backoffCoefficient: opts.backoff ?? 1,
+        ...opts.maxRetryIntervalMs ? { maximumInterval: opts.maxRetryIntervalMs } : {},
+        ...opts.nonRetryableTypes ? { nonRetryableErrorTypes: opts.nonRetryableTypes } : {}
+      }
+    });
+    proxies.set(key, p);
+  }
+  return p;
+}
+var childOptions = (app, args, opts) => ({
+  taskQueue: app,
+  workflowId: opts.id,
+  args,
+  ...opts.timeoutMs ? { workflowExecutionTimeout: opts.timeoutMs } : {},
+  ...opts.onExisting === "reject" ? { workflowIdReusePolicy: "REJECT_DUPLICATE" } : {}
+});
+var rethrow = (e) => {
+  throw fromTemporal(e);
+};
+function temporalFlow(flow, patches = []) {
+  return async (...args) => {
+    const inbox = new Map;
+    const state = new Map;
+    setHandler(signalDef, ({ topic, value }) => {
+      const q = inbox.get(topic) ?? [];
+      q.push(value);
+      inbox.set(topic, q);
+    });
+    setHandler(queryDef, (key) => state.get(key));
+    const info = workflowInfo();
+    const ctx = {
+      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) {
+        const h = await startChild(target.flow, {
+          ...childOptions(target.app, childArgs, { ...opts, onExisting: "reject" }),
+          parentClosePolicy: ParentClosePolicy.ABANDON
+        }).catch(rethrow);
+        return { id: opts.id, result: () => h.result().catch(rethrow) };
+      },
+      sleep: (ms) => sleep(ms),
+      async recv(topic, timeoutMs) {
+        const ready = await condition(() => (inbox.get(topic)?.length ?? 0) > 0, timeoutMs);
+        return ready ? inbox.get(topic).shift() : null;
+      },
+      signal: (workflowId, topic, value) => getExternalWorkflowHandle(workflowId).signal(signalDef, { topic, value }).catch((e) => {
+        if (!(e instanceof TemporalFailure))
+          throw e;
+        throw new FlowError2(`процесса ${workflowId} нет или он завершён`, { reason: "not-found" });
+      }),
+      async setState(key, value) {
+        state.set(key, value);
+      },
+      patched: async (id) => {
+        if (!patches.includes(id))
+          throw new Error(`патч "${id}" не объявлен в patches процесса`);
+        return patched(id);
+      },
+      deprecatePatch: async (id) => deprecatePatch(id)
+    };
+    try {
+      return await flow(ctx, ...args);
+    } catch (e) {
+      throw toTemporal(e, true);
+    }
+  };
+}
+export {
+  QUERY,
+  SIGNAL,
+  poolQueue,
+  temporalFlow
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iworkflow/temporal",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Temporal adapter for @iworkflow/core",
   "keywords": [
     "workflow",
@@ -13,23 +13,35 @@
     "directory": "packages/temporal"
   },
   "files": [
-    "src"
+    "src",
+    "!src/**/*.test.ts",
+    "dist"
   ],
   "type": "module",
   "sideEffects": false,
   "exports": {
-    ".": "./src/index.ts",
-    "./workflow": "./src/workflow.ts"
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./workflow": {
+      "bun": "./src/workflow.ts",
+      "types": "./dist/workflow.d.ts",
+      "default": "./dist/workflow.js"
+    }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
+    "build": "rm -rf dist && bun build src/index.ts src/workflow.ts --outdir dist --target node --format esm --packages external && tsc -p tsconfig.build.json",
     "type-check": "tsc --noEmit -p tsconfig.json",
-    "test": "bun test"
+    "test": "bun test",
+    "prepack": "bun run build"
   },
   "dependencies": {
-    "@iworkflow/core": "^0.3.0"
+    "@iworkflow/core": "^0.5.0"
   },
   "peerDependencies": {
     "@temporalio/activity": "^1.24.0",
@@ -44,5 +56,8 @@
     "@temporalio/common": "^1.24.0",
     "@temporalio/worker": "^1.24.0",
     "@temporalio/workflow": "^1.24.0"
+  },
+  "engines": {
+    "node": ">=22"
   }
 }

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

@@ -41,6 +41,8 @@ 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) } : {}),
     });
   if (isFlowError(e))
     return ApplicationFailure.create({ message: e.message, type: e.type ?? e.reason, details: [e.details], nonRetryable });

package/src/index.ts

@@ -4,13 +4,18 @@ import { Context } from "@temporalio/activity";
 import { NativeConnection, Worker } from "@temporalio/worker";
 import {
   bindStepRuntime,
+  checkPriority,
+  DEFAULT_PRIORITY,
+  exitSignal,
   FlowError,
   type Activity,
   type AppDefinition,
   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";
@@ -37,19 +42,32 @@ 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 доезжают до процесса. */
@@ -79,27 +97,33 @@ export function temporalRuntime(
   let running: Promise<void>[] = [];
   let conn: NativeConnection | undefined;
   let starting = false;
+  let stopping = false;
+  const exit = exitSignal();
   let stopRenew = () => {};
   return {
     async start(def: AppDefinition) {
       if (starting) throw new Error("воркер уже запущен");
       starting = true;
+      exit.arm();
+      stopping = false;
       bindStepRuntime({
         heartbeat: async (details) => Context.current().heartbeat(details),
         lastHeartbeat: async () => Context.current().info.heartbeatDetails,
+        attempt: () => Context.current().info.attempt,
       });
       let c: NativeConnection;
       try {
         c = conn = await NativeConnection.connect(await connectOptions(opts));
       } catch (e) {
         starting = false;
+        exit.reject(e);
         throw e;
       }
       stopRenew = renewApiKey(opts, (t) => c.setApiKey(t));
       // Воркер не создался (нет бандла, namespace) — соединение и таймер токена закрываются.
       try {
         const activities = withFailures(def.activities);
-        const base = { connection: c, namespace: namespace(opts) };
+        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 })];
         // Пул — своя очередь с пределом одновременных шагов в этом процессе.
@@ -124,11 +148,19 @@ export function temporalRuntime(
         conn = undefined;
         workers = [];
         starting = false;
+        exit.reject(e);
         throw e;
       }
       running = workers.map((w) => w.run());
+      // Воркер упал сам — done() отклоняется сразу, не дожидаясь stop.
+      // Отказ run() во время stop (срок дренажа) — не падение: done() решает stop.
+      // Воркеры погасил сам Runtime (SIGTERM) без stop — тоже конец цикла.
+      void Promise.all(running).then(() => stopping || exit.resolve(), () => {});
+      for (const r of running) r.catch((e) => stopping || exit.reject(e));
     },
+    done: () => exit.promise(),
     async stop() {
+      stopping = true;
       for (const w of workers) if (w.getState() === "RUNNING") w.shutdown();
       // Упавший воркер не мешает закрыть соединение и таймер токена.
       const done = await Promise.allSettled(running);
@@ -140,6 +172,7 @@ export function temporalRuntime(
         workers = [];
         running = [];
         starting = false;
+        exit.resolve();
       }
       const failed = done.find((r) => r.status === "rejected");
       if (failed) throw (failed as PromiseRejectedResult).reason;
@@ -147,22 +180,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/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>,

package/src/connection.test.ts

@@ -1,34 +0,0 @@
-import { expect, test } from "bun:test";
-import { connectOptions, renewApiKey } from "./connection";
-
-test("токен берётся при подключении и меняется по таймеру", async () => {
-  let n = 0;
-  const apiKey = async () => `t${++n}`;
-  expect(await connectOptions({ address: "a:1", tls: true, apiKey })).toEqual({ address: "a:1", tls: true, apiKey: "t1" });
-  const got: string[] = [];
-  const stop = renewApiKey({ apiKey, apiKeyRenewMs: 10 }, (t) => got.push(t));
-  while (got.length < 2) await Bun.sleep(5);
-  stop();
-  const seen = got.length;
-  await Bun.sleep(25);
-  expect(seen).toBeGreaterThanOrEqual(2);
-  expect(got.length).toBe(seen);
-});
-
-test("без токена и TLS — только адрес", async () => {
-  expect(await connectOptions({ address: "a:1" })).toEqual({ address: "a:1" });
-});
-
-test("медленный запрос не затирает свежий токен, после остановки токен не ставится", async () => {
-  let release!: (t: string) => void;
-  let calls = 0;
-  const apiKey = () => (++calls === 1 ? new Promise<string>((r) => (release = r)) : Promise.resolve(`t${calls}`));
-  const got: string[] = [];
-  const stop = renewApiKey({ apiKey, apiKeyRenewMs: 5 }, (t) => got.push(t));
-  await Bun.sleep(40);
-  expect(calls).toBe(1);
-  stop();
-  release("old");
-  await Bun.sleep(5);
-  expect(got).toEqual([]);
-});