lightflow-engine 0.2.9 → 0.2.10

package/dist/compat/metadata.js

@@ -1,9 +1,10 @@
 /**
  * Vercel Workflow compat: getWorkflowMetadata() returns { workflowRunId }.
  */
-import { current } from "../index.js";
+import { getCurrent } from "../index.js";
 export function getWorkflowMetadata() {
-    if (!current)
+    const ctx = getCurrent();
+    if (!ctx)
         throw new Error("getWorkflowMetadata() outside a workflow");
-    return { workflowRunId: current.runId };
+    return { workflowRunId: ctx.runId };
 }

package/dist/compat/workflow.js

@@ -9,7 +9,7 @@
  */
 import { createHash } from "node:crypto";
 import { step, registerStep, } from "../index.js";
-import { current } from "../index.js";
+import { getCurrent } from "../index.js";
 export { FatalError, CancelledError, sleep } from "../index.js";
 export { getWorkflowMetadata } from "../compat/metadata.js";
 // Vercel exports the step-aware fetch under both names; entry-agents
@@ -23,7 +23,7 @@ export { workflowFetch } from "../compat/fetch.js";
  * terminal done marker.
  */
 export function getWritable() {
-    const ctx = current;
+    const ctx = getCurrent();
     if (!ctx)
         throw new Error("getWritable() outside a workflow");
     const underlying = {

package/dist/index.d.ts

@@ -102,7 +102,7 @@ type Ctx = {
     chunks: string[];
     now: () => number;
 };
-export declare let current: Ctx | null;
+export declare function getCurrent(): Ctx | null;
 export declare function getWorkflowMetadata(): {
     runId: string;
 };

package/dist/index.js

@@ -39,28 +39,28 @@ export function registerWorkflow(id, fn) {
 export function registerStep(id, fn) {
     steps.set(id, fn);
 }
-export let current = globalThis.__lightflowCurrent ?? null;
-if (!globalThis.__lightflowCurrent) {
-    globalThis.__lightflowCurrent = null;
+// Cross-bundle execution context: Next.js may execute the engine and workflow
+// code from different module instances of this file. `current` must be visible
+// across all of them, so it lives on globalThis and is read via getCurrent().
+export function getCurrent() {
+    return globalThis.__lightflowCurrent ?? null;
 }
-// Keep the live binding in sync: `current` assignments below must write both.
 function setCurrent(v) {
-    current = v;
     globalThis.__lightflowCurrent = v;
 }
 // Rewrite plain assignments on `current` below to setCurrent(...)
 export function getWorkflowMetadata() {
-    if (!current)
+    if (!getCurrent())
         throw new Error("getWorkflowMetadata() outside a workflow");
-    return { runId: current.runId };
+    return { runId: getCurrent().runId };
 }
 /* ------------------------------------------------------------------ */
 /* The step id: derived from call order, so replay is deterministic    */
 /* ------------------------------------------------------------------ */
 function nextStepKey() {
-    if (!current)
+    if (!getCurrent())
         throw new Error("steps can only be called inside a workflow");
-    return `step:${current.stepCalls}`;
+    return `step:${getCurrent().stepCalls}`;
 }
 /* ------------------------------------------------------------------ */
 /* Public API inside a workflow                                        */
@@ -70,9 +70,9 @@ function nextStepKey() {
  * the function body is NOT re-executed.
  */
 export async function step(fn) {
-    if (!current)
+    if (!getCurrent())
         return fn(); // plain call outside a workflow
-    const ctx = current;
+    const ctx = getCurrent();
     const key = nextStepKey();
     ctx.stepCalls += 1;
     // Replay: memoized result for this call position? (O(1) map lookup)
@@ -163,11 +163,11 @@ async function maybeSnapshot(ctx) {
 }
 /** Durable sleep. Accepts milliseconds or an absolute Date. */
 export async function sleep(until) {
-    if (!current) {
+    if (!getCurrent()) {
         const ms = until instanceof Date ? until.getTime() - Date.now() : until;
         return new Promise((r) => setTimeout(r, Math.max(0, ms)));
     }
-    const ctx = current;
+    const ctx = getCurrent();
     const wakeAt = until instanceof Date ? until.getTime() : ctx.now() + until;
     const key = `sleep:${ctx.sleepCalls}`;
     ctx.sleepCalls += 1;
@@ -192,8 +192,8 @@ export class SuspendSignal {
 }
 /** Ordered output stream for a run. Chunks are persisted and replayable. */
 export function getWritable() {
-    const ctx = current;
-    if (!current)
+    const ctx = getCurrent();
+    if (!getCurrent())
         throw new Error("getWritable() outside a workflow");
     return {
         async write(chunk) {
@@ -377,7 +377,7 @@ export class Engine {
                 return p;
             },
         };
-        const prev = current;
+        const prev = getCurrent();
         setCurrent(ctx);
         try {
             const output = await fn(...args);
@@ -533,21 +533,21 @@ export class CancelledError extends Error {
 export function defineHook() {
     return {
         async create() {
-            if (!current)
+            if (!getCurrent())
                 throw new Error("hooks only inside a workflow");
             const token = `hook_${randomUUID().replace(/-/g, "").slice(0, 20)}`;
-            const key = `hook:${current.hookCalls}`;
-            current.hookCalls += 1;
-            await current.store.createHook?.(current.runId, token, key);
+            const key = `hook:${getCurrent().hookCalls}`;
+            getCurrent().hookCalls += 1;
+            await getCurrent().store.createHook?.(getCurrent().runId, token, key);
             return { token };
         },
     };
 }
 /** Await a previously created hook until an external caller resolves it. */
 export async function hookResult(token) {
-    if (!current)
+    if (!getCurrent())
         throw new Error("hooks only inside a workflow");
-    const existing = await current.store.getHook?.(token);
+    const existing = await getCurrent().store.getHook?.(token);
     if (existing && existing.payload?.resolved) {
         return existing.payload.value;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lightflow-engine",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "A tiny durable workflow engine for Node.js and Postgres — with a Vercel Workflow drop-in compat layer.",
   "license": "MIT",
   "type": "module",