@teleporthq/teleport-plugin-next-workflows 0.43.47 → 0.43.49

package/__tests__/data-node-not-awaited.test.ts

@@ -476,12 +476,23 @@ describe('generated client runtime', () => {
   const client = generateClientRuntimeCode()
 
   it('dispatches an all-fire-and-forget segment without awaiting the round trip', () => {
-    expect(client).toContain('if (seg.fireAndForget) {')
+    expect(client).toContain('if (segIsFireAndForget) {')
     expect(client).toContain('callServerSegment(ffUrl, context).catch(')
     // The nodes still get their null entries so downstream reads are defined.
     expect(client).toContain('context[seg.nodes[ffi].id] = null;')
   })
 
+  it('upgrades a mixed segment to fire-and-forget when the awaited nodes were branch-skipped', () => {
+    // Static flag first, then the dynamic check over the LIVE (non-skipped)
+    // nodes — a mixed segment whose awaited nodes sit on a branch that was
+    // not taken has only fire-and-forget work left to do.
+    expect(client).toContain(
+      'var segLiveNodes = seg.nodes.filter(function(n) { return !(context.__skippedNodes && context.__skippedNodes[n.id]); });'
+    )
+    expect(client).toContain('var segIsFireAndForget = seg.fireAndForget ||')
+    expect(client).toContain('segLiveNodes.every(utils.isFireAndForgetNode)')
+  })
+
   it('keeps awaiting a normal server segment', () => {
     expect(client).toContain('const serverResults = await callServerSegment(url, context);')
   })

package/__tests__/ecommerce-get-settings-client.test.ts

@@ -0,0 +1,383 @@
+import { splitIntoSegments, generateSharedRuntimeUtilsCode } from '../src'
+import { nodeRegistry } from '../src/nodes'
+import { NextWorkflowProjectPlugin } from '../src/workflow-project-plugin'
+import { UIDLWorkflow } from '@teleporthq/teleport-types'
+
+// The /api/ecommerce/settings route returns a literal baked at generation time
+// — within a deployment it can never say anything else. Classifying the
+// `ecommerce-get-settings` node as a SERVER node therefore bought nothing and
+// cost a full blocking round trip per click, PLUS it fragmented the
+// surrounding workflow into extra server segments (one round trip each).
+//
+// The contract this file pins down:
+//   1. the node is client-classified, so the segment splitter never mints a
+//      server segment for it;
+//   2. the client handler resolves from the baked window global first, then a
+//      memoized fetch, then the route;
+//   3. cron/webhook routes (which execute every node server-side, with no
+//      window) still get a real server implementation via
+//      generateServerHandler — never the client-only stub;
+//   4. the add-to-cart / cart-increment workflow shapes collapse to exactly
+//      ONE server segment: the product data-select.
+
+describe('ecommerce-get-settings node classification', () => {
+  const generator = nodeRegistry['ecommerce-get-settings']
+
+  it('is client-classified', () => {
+    expect(generator.executionEnv).toBe('client')
+  })
+
+  it('client handler reads the baked global, memoizes the fetch fallback', () => {
+    const source = generator.generateHandler()
+    expect(source).toContain('__teleportEcommerceSettings')
+    expect(source).toContain('__teleportEcommerceSettingsFetched')
+    expect(source).toContain('/api/ecommerce/settings')
+  })
+
+  it('keeps a real server implementation for cron/webhook contexts', () => {
+    expect(generator.generateServerHandler).toBeDefined()
+    const source = generator.generateServerHandler!()
+    expect(source).toContain('/api/ecommerce/settings')
+    expect(source).not.toContain('window')
+  })
+})
+
+describe('ecommerce-get-settings client handler behaviour', () => {
+  const buildHandler = () => {
+    const source = nodeRegistry['ecommerce-get-settings'].generateHandler()
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    return new Function(`return (${source})`)() as (
+      config: unknown,
+      context: Record<string, unknown>
+    ) => Promise<Record<string, unknown>>
+  }
+
+  const globalAny = global as unknown as Record<string, unknown>
+
+  afterEach(() => {
+    delete globalAny.window
+    delete globalAny.fetch
+  })
+
+  it('returns the baked global without fetching', async () => {
+    const baked = { guestCheckout: true, stockManagement: true, maxQuantityPerProduct: null }
+    globalAny.window = { __teleportEcommerceSettings: baked }
+    globalAny.fetch = jest.fn()
+
+    const result = await buildHandler()({}, {})
+    expect(result).toBe(baked)
+    expect(globalAny.fetch).not.toHaveBeenCalled()
+  })
+
+  it('falls back to the route and memoizes a successful response', async () => {
+    const payload = { guestCheckout: false, stockManagement: true }
+    globalAny.window = {}
+    const fetchMock = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => payload,
+    })
+    globalAny.fetch = fetchMock
+
+    const handler = buildHandler()
+    const first = await handler({}, {})
+    expect(first).toEqual(payload)
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+
+    // Second call resolves from the memo — the route is immutable within a
+    // deployment, so this can never serve stale data.
+    const second = await handler({}, {})
+    expect(second).toEqual(payload)
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not memoize a failed response', async () => {
+    globalAny.window = {}
+    const fetchMock = jest
+      .fn()
+      .mockResolvedValueOnce({ ok: false })
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ guestCheckout: true }) })
+    globalAny.fetch = fetchMock
+
+    const handler = buildHandler()
+    const first = await handler({}, {})
+    expect(first).toEqual({ error: 'Failed to load e-commerce settings' })
+
+    const second = await handler({}, {})
+    expect(second).toEqual({ guestCheckout: true })
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+  })
+})
+
+describe('segment shapes around a client settings node', () => {
+  const node = (id: string, type: string, config: Record<string, unknown> = {}) => ({
+    id,
+    type,
+    label: id,
+    config,
+    stepNumber: 0,
+  })
+  const edge = (source: string, target: string, sourceHandle?: string) => ({
+    id: `${source}->${target}`,
+    source,
+    target,
+    ...(sourceHandle ? { sourceHandle } : {}),
+  })
+
+  it('cart-increment shape: ONE server segment holding only the data-select', () => {
+    // trigger → data-select (server) → get-settings → validate (client js) → if
+    const workflow = {
+      nodes: [
+        node('trigger', 'event-element-clicked', { isFirstNode: true }),
+        node('fetch-product', 'data-select', { tableName: 'teleport_products' }),
+        node('get-settings', 'ecommerce-get-settings'),
+        node('validate', 'general-custom-js', {
+          code: 'function customHandler(p){}',
+          context: 'client',
+        }),
+        node('gate', 'general-if-statement', {}),
+      ],
+      edges: [
+        edge('trigger', 'fetch-product'),
+        edge('fetch-product', 'get-settings'),
+        edge('get-settings', 'validate'),
+        edge('validate', 'gate'),
+      ],
+    } as unknown as UIDLWorkflow
+
+    const segments = splitIntoSegments(workflow)
+    const serverSegments = segments.filter((s) => s.env === 'server')
+    expect(serverSegments).toHaveLength(1)
+    expect(serverSegments[0].nodes.map((n) => n.id)).toEqual(['fetch-product'])
+  })
+
+  it('add-to-cart shape: settings between client nodes mints NO server segment', () => {
+    // extract (client js) → get-settings → guest-check (client js) → if →
+    // [redirect | data-select] — only the data-select is a server segment.
+    const workflow = {
+      nodes: [
+        node('extract', 'general-custom-js', {
+          code: 'function customHandler(p){}',
+          context: 'client',
+        }),
+        node('get-settings', 'ecommerce-get-settings'),
+        node('guest-check', 'general-custom-js', {
+          code: 'function customHandler(p){}',
+          context: 'client',
+        }),
+        node('gate', 'general-if-statement', {}),
+        node('redirect', 'navigation-navigate-to-url', { url: '/sign-in' }),
+        node('fetch-product', 'data-select', { tableName: 'teleport_products' }),
+      ],
+      edges: [
+        edge('extract', 'get-settings'),
+        edge('get-settings', 'guest-check'),
+        edge('guest-check', 'gate'),
+        edge('gate', 'redirect', 'true'),
+        edge('gate', 'fetch-product', 'false'),
+      ],
+    } as unknown as UIDLWorkflow
+
+    const segments = splitIntoSegments(workflow)
+    const serverSegments = segments.filter((s) => s.env === 'server')
+    expect(serverSegments).toHaveLength(1)
+    expect(serverSegments[0].nodes.map((n) => n.id)).toEqual(['fetch-product'])
+  })
+})
+
+// ─── Dynamic fire-and-forget upgrade, end to end ─────────────────────────────
+//
+// Mirrors the "Resolve Current User" custom node's anonymous half: an
+// if-statement routes a RETURNING guest to a fire-and-forget users-row
+// re-ensure and a NEW guest to an awaited create. Both data nodes land in one
+// server segment, so the segment is statically mixed (fireAndForget: false).
+// When the taken branch leaves only fire-and-forget work live, the runtime
+// must dispatch the segment WITHOUT awaiting; when the awaited branch is
+// taken, it must still block.
+describe('generated custom node — mixed segment upgrades to fire-and-forget per branch', () => {
+  const customNodes = {
+    'cn-resolve': {
+      id: 'cn-resolve',
+      name: 'Resolve-ish',
+      parameters: [],
+      nodes: [
+        {
+          id: 'extract',
+          type: 'general-custom-js',
+          label: 'Extract',
+          config: {
+            code: 'function customHandler(p, q) { return { returning: true } }',
+            context: 'client',
+          },
+          executionEnv: 'client',
+          stepNumber: 0,
+        },
+        {
+          id: 'gate',
+          type: 'general-if-statement',
+          label: 'Returning Guest?',
+          config: {
+            conditionType: 'simple-comparison',
+            leftValue: {
+              type: 'workflowContext',
+              nodeId: 'extract',
+              path: ['extract', 'returning'],
+            },
+            operator: '===',
+            rightValue: true,
+          },
+          executionEnv: 'client',
+          stepNumber: 1,
+        },
+        {
+          id: 'ensure',
+          type: 'data-create-item',
+          label: 'Ensure Row',
+          config: { awaitResult: false },
+          executionEnv: 'server',
+          stepNumber: 2,
+        },
+        {
+          id: 'create',
+          type: 'data-create-item',
+          label: 'Create Row',
+          config: {},
+          executionEnv: 'server',
+          stepNumber: 2,
+        },
+        {
+          id: 'return-stored',
+          type: 'general-custom-js',
+          label: 'Return Stored',
+          config: {
+            code: 'function customHandler(p, q) { return { branch: "stored" } }',
+            context: 'client',
+          },
+          executionEnv: 'client',
+          stepNumber: 3,
+        },
+        {
+          id: 'return-new',
+          type: 'general-custom-js',
+          label: 'Return New',
+          config: {
+            code: 'function customHandler(p, q) { return { branch: "new" } }',
+            context: 'client',
+          },
+          executionEnv: 'client',
+          stepNumber: 3,
+        },
+      ],
+      edges: [
+        { id: 'e1', source: 'extract', target: 'gate' },
+        { id: 'e2', source: 'gate', target: 'ensure', sourceHandle: 'true' },
+        { id: 'e3', source: 'gate', target: 'create', sourceHandle: 'false' },
+        { id: 'e4', source: 'ensure', target: 'return-stored' },
+        { id: 'e5', source: 'create', target: 'return-new' },
+      ],
+    },
+  }
+
+  interface BootedCustomNode {
+    run: (
+      outerContext: Record<string, unknown>,
+      parameters: Record<string, unknown>,
+      handlers: Record<string, unknown>
+    ) => Promise<unknown>
+    segmentCalls: string[]
+    resolveSegment: () => void
+  }
+
+  const bootCustomNode = (): BootedCustomNode => {
+    const plugin = new NextWorkflowProjectPlugin() as unknown as {
+      generateCustomNodesFile: (
+        nodes: Record<string, unknown>,
+        urls: Record<string, Record<string, string>>
+      ) => string
+    }
+    const source = plugin.generateCustomNodesFile(customNodes, {
+      'cn-resolve': { 'server-1': '/api/workflows/resolve-seg-1' },
+    })
+
+    const utilsModule: { exports: Record<string, unknown> } = { exports: {} }
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    new Function('module', 'exports', generateSharedRuntimeUtilsCode())(
+      utilsModule,
+      utilsModule.exports
+    )
+
+    const segmentCalls: string[] = []
+    let releaseSegment: () => void = () => undefined
+    const segmentGate = new Promise<void>((resolve) => {
+      releaseSegment = resolve
+    })
+    const runtimeStub = {
+      findStreamingAINodes: () => ({}),
+      mergeServerResults: () => undefined,
+      callStreamingServerSegment: async () => ({}),
+      callServerSegment: async (url: string) => {
+        segmentCalls.push(url)
+        await segmentGate
+        return {}
+      },
+    }
+
+    const requireStub = (id: string) =>
+      id === './runtime-utils' ? utilsModule.exports : id === './runtime' ? runtimeStub : {}
+
+    const moduleStub: { exports: Record<string, unknown> } = { exports: {} }
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    new Function('module', 'exports', 'require', source)(
+      moduleStub,
+      moduleStub.exports,
+      requireStub
+    )
+
+    const registry = moduleStub.exports as Record<string, BootedCustomNode['run']>
+    return { run: registry['cn-resolve'], segmentCalls, resolveSegment: releaseSegment }
+  }
+
+  const handlersFor = (returning: boolean) => ({
+    'general-custom-js': async (config: { code?: string }) => {
+      const code = config && config.code ? config.code : ''
+      if (code.includes('returning')) {
+        return { returning }
+      }
+      if (code.includes('stored')) {
+        return { branch: 'stored' }
+      }
+      return { branch: 'new' }
+    },
+  })
+
+  it('returning-guest branch (only fire-and-forget live) does not await the segment', async () => {
+    const booted = bootCustomNode()
+
+    // The gate promise is never released — if the runtime awaited the segment
+    // this would hang and jest would time the test out.
+    const result = (await booted.run({}, {}, handlersFor(true))) as Record<string, unknown>
+
+    expect(booted.segmentCalls).toEqual(['/api/workflows/resolve-seg-1'])
+    expect(result).toEqual({ branch: 'stored' })
+
+    booted.resolveSegment()
+  })
+
+  it('new-guest branch (awaited create live) still blocks on the segment', async () => {
+    const booted = bootCustomNode()
+
+    let settled = false
+    const running = booted.run({}, {}, handlersFor(false)).then((value) => {
+      settled = true
+      return value
+    })
+
+    // Give the runtime ample turns to (incorrectly) run to completion.
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    expect(booted.segmentCalls).toEqual(['/api/workflows/resolve-seg-1'])
+    expect(settled).toBe(false)
+
+    booted.resolveSegment()
+    const result = (await running) as Record<string, unknown>
+    expect(result).toEqual({ branch: 'new' })
+  })
+})

package/__tests__/runtime-stringified-boolean-truthiness.test.ts

@@ -0,0 +1,76 @@
+import { generateSharedRuntimeUtilsCode } from '../src'
+
+// Producers that cannot type their output emit booleans as the strings
+// "true"/"false" — the evaluate-auth custom-js most notably (see
+// is-logged-in-gate.ts), plus any inspector text input. `is-true`/`is-false`
+// and coerceForComparison already read those as booleans, but `is-truthy` was
+// plain `!!left`, and the string "false" is truthy in JS: an is-truthy gate on
+// isLoggedIn admitted EVERY visitor, and an is-falsy check never fired.
+
+type SharedUtils = {
+  evaluateSingleComparison: (cfg: unknown, ctx: Record<string, unknown>) => boolean
+}
+
+function loadSharedRuntime(): SharedUtils {
+  const src = generateSharedRuntimeUtilsCode()
+  const wrapper: { exports: Record<string, unknown> } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', src)(wrapper, wrapper.exports)
+  return wrapper.exports as unknown as SharedUtils
+}
+
+describe('workflow runtime truthiness of stringified booleans', () => {
+  const utils = loadSharedRuntime()
+
+  const isTruthy = (leftValue: unknown) =>
+    utils.evaluateSingleComparison({ leftValue, operator: 'is-truthy' }, {})
+  const isFalsy = (leftValue: unknown) =>
+    utils.evaluateSingleComparison({ leftValue, operator: 'is-falsy' }, {})
+
+  it('treats the string "false" as false, matching is-false and coerceForComparison', () => {
+    expect(isTruthy('false')).toBe(false)
+    expect(isFalsy('false')).toBe(true)
+  })
+
+  it('keeps the string "true" true', () => {
+    expect(isTruthy('true')).toBe(true)
+    expect(isFalsy('true')).toBe(false)
+  })
+
+  it('agrees with is-true/is-false on the same value', () => {
+    for (const value of ['true', 'false', true, false]) {
+      expect(isTruthy(value)).toBe(
+        utils.evaluateSingleComparison({ leftValue: value, operator: 'is-true' }, {})
+      )
+      expect(isFalsy(value)).toBe(
+        utils.evaluateSingleComparison({ leftValue: value, operator: 'is-false' }, {})
+      )
+    }
+  })
+
+  it('leaves ordinary JS truthiness untouched', () => {
+    expect(isTruthy(true)).toBe(true)
+    expect(isTruthy(false)).toBe(false)
+    expect(isTruthy('anything')).toBe(true)
+    expect(isTruthy('')).toBe(false)
+    expect(isTruthy(0)).toBe(false)
+    expect(isTruthy(1)).toBe(true)
+    expect(isTruthy(null)).toBe(false)
+    expect(isTruthy(undefined)).toBe(false)
+    expect(isFalsy('')).toBe(true)
+    expect(isFalsy(0)).toBe(true)
+    expect(isFalsy('anything')).toBe(false)
+  })
+
+  it('normalizes the snake_case and camelCase spellings the same way', () => {
+    expect(utils.evaluateSingleComparison({ leftValue: 'false', operator: 'is_truthy' }, {})).toBe(
+      false
+    )
+    expect(utils.evaluateSingleComparison({ leftValue: 'false', operator: 'isTruthy' }, {})).toBe(
+      false
+    )
+    expect(utils.evaluateSingleComparison({ leftValue: 'false', operator: 'is_falsy' }, {})).toBe(
+      true
+    )
+  })
+})

package/dist/cjs/executor-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"executor-generator.d.ts","sourceRoot":"","sources":["../../src/executor-generator.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,QAAO,MAutCjD,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MA0f5C,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MAK5C,CAAA"}
+{"version":3,"file":"executor-generator.d.ts","sourceRoot":"","sources":["../../src/executor-generator.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,QAAO,MAiuCjD,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MAqgB5C,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MAK5C,CAAA"}

package/dist/cjs/executor-generator.js

@@ -543,6 +543,16 @@ function coerceForComparison(a, b) {
   return [a, b];
 }
 
+// Several producers cannot type their output and emit booleans as the strings
+// "true"/"false": the evaluate-auth custom-js, text inputs in the inspector,
+// form fields. coerceForComparison and is-true/is-false already read those as
+// booleans, so truthiness must agree — under a plain double-negation the
+// string "false" is TRUTHY, which let an is-truthy gate on isLoggedIn admit
+// every visitor (see is-logged-in-gate.ts).
+function isStringifiedBoolean(value) {
+  return value === 'true' || value === 'false';
+}
+
 // The operator vocabulary is written by THREE producers that never agreed on
 // a spelling: the worker canonicalizes to snake_case (is_not_empty,
 // greater_than), the GUI editor emits camelCase named forms (startsWith,
@@ -587,8 +597,8 @@ function evaluateSingleComparison(config, context) {
     case 'is-not-null': return left !== null && left !== undefined;
     case 'is-true': return left === true || left === 'true';
     case 'is-false': return left === false || left === 'false';
-    case 'is-truthy': return !!left;
-    case 'is-falsy': return !left;
+    case 'is-truthy': return isStringifiedBoolean(left) ? left === 'true' : !!left;
+    case 'is-falsy': return isStringifiedBoolean(left) ? left === 'false' : !left;
     case 'matches-regex': try { return new RegExp(String(right)).test(String(left)); } catch(e) { return false; }
     default:
       console.warn('[workflow] Unknown comparison operator "' + config.operator + '" — falling back to loose equality');
@@ -1606,7 +1616,18 @@ async function executeWorkflowWithSegments(workflowConfig, triggerContext, clien
         // still awaits each query before it responds; we simply ignore the
         // response. Errors are logged, never routed to the error handler:
         // the workflow already moved past this point.
-        if (seg.fireAndForget) {
+        //
+        // seg.fireAndForget is computed STATICALLY (every node in the segment
+        // is a fire-and-forget data node). A segment that MIXES fire-and-forget
+        // and awaited nodes stays blocking statically — but when branch
+        // skipping has already eliminated the awaited nodes at runtime, only
+        // fire-and-forget work remains, so the same "nothing downstream can
+        // read it" guarantee holds for the nodes that will actually run. The
+        // dynamic check below upgrades exactly that case.
+        var segLiveNodes = seg.nodes.filter(function(n) { return !(context.__skippedNodes && context.__skippedNodes[n.id]); });
+        var segIsFireAndForget = seg.fireAndForget ||
+          (segLiveNodes.length > 0 && segLiveNodes.every(utils.isFireAndForgetNode));
+        if (segIsFireAndForget) {
           const ffUrl = serverSegmentUrls[seg.id];
           if (!ffUrl) throw new Error('No server URL for segment: ' + seg.id);
           utils.registerPendingNodePromise(

package/dist/cjs/executor-generator.js.map

@@ -1 +1 @@
-{"version":3,"file":"executor-generator.js","sourceRoot":"","sources":["../../src/executor-generator.ts"],"names":[],"mappings":";;;AAAO,MAAM,8BAA8B,GAAG,GAAW,EAAE;IACzD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqtCR,CAAA;AACD,CAAC,CAAA;AAvtCY,QAAA,8BAA8B,kCAutC1C;AAEM,MAAM,yBAAyB,GAAG,GAAW,EAAE;IACpD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwfR,CAAA;AACD,CAAC,CAAA;AA1fY,QAAA,yBAAyB,6BA0frC;AAEM,MAAM,yBAAyB,GAAG,GAAW,EAAE;IACpD,OAAO;;;CAGR,CAAA;AACD,CAAC,CAAA;AALY,QAAA,yBAAyB,6BAKrC"}
+{"version":3,"file":"executor-generator.js","sourceRoot":"","sources":["../../src/executor-generator.ts"],"names":[],"mappings":";;;AAAO,MAAM,8BAA8B,GAAG,GAAW,EAAE;IACzD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+tCR,CAAA;AACD,CAAC,CAAA;AAjuCY,QAAA,8BAA8B,kCAiuC1C;AAEM,MAAM,yBAAyB,GAAG,GAAW,EAAE;IACpD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmgBR,CAAA;AACD,CAAC,CAAA;AArgBY,QAAA,yBAAyB,6BAqgBrC;AAEM,MAAM,yBAAyB,GAAG,GAAW,EAAE;IACpD,OAAO;;;CAGR,CAAA;AACD,CAAC,CAAA;AALY,QAAA,yBAAyB,6BAKrC"}

package/dist/cjs/nodes/account/account-get-current.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"account-get-current.d.ts","sourceRoot":"","sources":["../../../../src/nodes/account/account-get-current.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AAoGhE,eAAO,MAAM,iBAAiB,EAAE,oBAS/B,CAAA"}
+{"version":3,"file":"account-get-current.d.ts","sourceRoot":"","sources":["../../../../src/nodes/account/account-get-current.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AAuHhE,eAAO,MAAM,iBAAiB,EAAE,oBAS/B,CAAA"}

package/dist/cjs/nodes/account/account-get-current.js

@@ -46,16 +46,36 @@ async function account_get_current(_config, context) {
     // callback re-reads the `users` row) BEFORE the workflow's own request could
     // start — for data the page had since it mounted.
     //
-    // Only 'authenticated' short-circuits. 'loading' means the provider's first
-    // fetch has not settled; 'unauthenticated' is also what next-auth reports when
-    // that fetch FAILED, and treating a transient error as "signed out" would send
-    // a signed-in visitor down the guest branch. Both fall through to the fetch —
-    // which for a guest is the cheap case anyway, since the jwt callback returns
-    // before touching the database when there is no token.
+    // Only 'authenticated' short-circuits. 'unauthenticated' is also what
+    // next-auth reports when the provider's fetch FAILED, and treating a
+    // transient error as "signed out" would send a signed-in visitor down the
+    // guest branch. It falls through to the fetch — which for a guest is the
+    // cheap case anyway, since the jwt callback returns before touching the
+    // database when there is no token.
+    //
+    // 'loading' means the provider's FIRST /api/auth/session fetch is still in
+    // flight (a click that lands within ~a second of page load). Issuing our own
+    // fetch at that moment duplicates the exact request already on the wire —
+    // including its jwt-callback user-row read. Instead, briefly poll the bridge
+    // snapshot until the in-flight fetch settles; the bounded deadline means a
+    // hung provider fetch degrades to today's behaviour (our own fetch) instead
+    // of stalling the workflow.
     if (typeof window !== 'undefined') {
         try {
             const bridge = window.__teleportNextAuth;
-            const snapshot = bridge && typeof bridge.getSession === 'function' ? bridge.getSession() : null;
+            let snapshot = bridge && typeof bridge.getSession === 'function' ? bridge.getSession() : null;
+            if (snapshot && snapshot.status === 'loading') {
+                const deadline = Date.now() + 3000;
+                while (Date.now() < deadline) {
+                    await new Promise(function (resolve) {
+                        setTimeout(resolve, 50);
+                    });
+                    snapshot = bridge.getSession();
+                    if (!snapshot || snapshot.status !== 'loading') {
+                        break;
+                    }
+                }
+            }
             if (snapshot && snapshot.status === 'authenticated') {
                 const liveUser = snapshot.session && snapshot.session.user ? snapshot.session.user : null;
                 if (liveUser) {

package/dist/cjs/nodes/account/account-get-current.js.map

@@ -1 +1 @@
-{"version":3,"file":"account-get-current.js","sourceRoot":"","sources":["../../../../src/nodes/account/account-get-current.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"account-get-current.js","sourceRoot":"","sources":["../../../../src/nodes/account/account-get-current.ts"],"names":[],"mappings":";;;AAAA,oCAAgE;AAEhE,KAAK,UAAU,mBAAmB,CAAC,OAAgB,EAAE,OAAgC;IACnF,MAAM,OAAO,GAAG,CAAC,OAAO,IAAK,OAAe,CAAC,SAAS,CAAC,IAAI,EAAE,CAAA;IAC7D,yEAAyE;IACzE,2EAA2E;IAC3E,4EAA4E;IAC5E,4EAA4E;IAC5E,+BAA+B;IAC/B,6EAA6E;IAC7E,yEAAyE;IACzE,2DAA2D;IAC3D,MAAM,KAAK,GAAG,CAAC,IAAS,EAAE,EAAE;QAC1B,MAAM,CAAC,GAAQ,EAAE,CAAA;QACjB,IAAI,IAAI,EAAE;YACR,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAClC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;aACvB;SACF;QACD,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI,IAAI,CAAA;QACrB,OAAO,CAAC,CAAA;IACV,CAAC,CAAA;IACD,mEAAmE;IACnE,gEAAgE;IAChE,MAAM,OAAO,GAAG,CAAC,IAAS,EAAE,EAAE;QAC5B,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;YACjC,OAAM;SACP;QACD,IAAI;YACF,IAAI,IAAI,EAAE;gBACR,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,oBAAoB,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAA;aACxE;iBAAM;gBACL,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAA;aACrD;SACF;QAAC,OAAO,EAAE,EAAE,GAAE;IACjB,CAAC,CAAA;IAED,8EAA8E;IAC9E,4EAA4E;IAC5E,+EAA+E;IAC/E,uEAAuE;IACvE,6EAA6E;IAC7E,kDAAkD;IAClD,EAAE;IACF,sEAAsE;IACtE,qEAAqE;IACrE,0EAA0E;IAC1E,yEAAyE;IACzE,wEAAwE;IACxE,mCAAmC;IACnC,EAAE;IACF,2EAA2E;IAC3E,6EAA6E;IAC7E,0EAA0E;IAC1E,6EAA6E;IAC7E,2EAA2E;IAC3E,4EAA4E;IAC5E,4BAA4B;IAC5B,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;QACjC,IAAI;YACF,MAAM,MAAM,GAAI,MAAc,CAAC,kBAAkB,CAAA;YACjD,IAAI,QAAQ,GAAG,MAAM,IAAI,OAAO,MAAM,CAAC,UAAU,KAAK,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,CAAA;YAC7F,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,EAAE;gBAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAA;gBAClC,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,EAAE;oBAC5B,MAAM,IAAI,OAAO,CAAC,UAAU,OAAO;wBACjC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;oBACzB,CAAC,CAAC,CAAA;oBACF,QAAQ,GAAG,MAAM,CAAC,UAAU,EAAE,CAAA;oBAC9B,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,EAAE;wBAC9C,MAAK;qBACN;iBACF;aACF;YACD,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,eAAe,EAAE;gBACnD,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,IAAI,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAA;gBACzF,IAAI,QAAQ,EAAE;oBACZ,OAAO,CAAC,QAAQ,CAAC,CAAA;oBACjB,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAA;iBACvB;aACF;SACF;QAAC,OAAO,EAAE,EAAE,GAAE;KAChB;IAED,IAAI;QACF,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,OAAO,GAAG,mBAAmB,CAAC,CAAA;QAC3D,IAAI,QAAQ,CAAC,EAAE,EAAE;YACf,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;YACrC,MAAM,IAAI,GAAG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAA;YAE1D,OAAO,CAAC,IAAI,CAAC,CAAA;YAEb,OAAO,KAAK,CAAC,IAAI,CAAC,CAAA;SACnB;QAED,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;YACjC,IAAI;gBACF,MAAM,MAAM,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAA;gBAChE,IAAI,MAAM,EAAE;oBACV,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;iBACjC;aACF;YAAC,OAAO,EAAE,EAAE,GAAE;SAChB;QAED,OAAO,KAAK,CAAC,IAAI,CAAC,CAAA;KACnB;IAAC,OAAO,GAAY,EAAE;QACrB,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;YACjC,IAAI;gBACF,MAAM,QAAQ,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAA;gBAClE,IAAI,QAAQ,EAAE;oBACZ,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAA;iBACnC;aACF;YAAC,OAAO,EAAE,EAAE,GAAE;SAChB;QACD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAG,GAAa,CAAC,OAAO,EAAE,CAAA;KACrD;AACH,CAAC;AAEY,QAAA,iBAAiB,GAAyB;IACrD,QAAQ,EAAE,qBAAqB;IAC/B,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE;QACZ,WAAW,EAAE,SAAS;KACvB;IACD,eAAe;QACb,OAAO,IAAA,uBAAe,EAAC,mBAAmB,CAAC,CAAA;IAC7C,CAAC;CACF,CAAA"}

package/dist/cjs/nodes/ecommerce/ecommerce-get-settings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ecommerce-get-settings.d.ts","sourceRoot":"","sources":["../../../../src/nodes/ecommerce/ecommerce-get-settings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AAoBhE,eAAO,MAAM,oBAAoB,EAAE,oBAMlC,CAAA"}
+{"version":3,"file":"ecommerce-get-settings.d.ts","sourceRoot":"","sources":["../../../../src/nodes/ecommerce/ecommerce-get-settings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AAyEhE,eAAO,MAAM,oBAAoB,EAAE,oBAYlC,CAAA"}