@teleporthq/teleport-plugin-next-workflows 0.43.9 → 0.43.11

package/__tests__/state-update-default-value.test.ts

@@ -0,0 +1,286 @@
+// Regression guard for "state-update node wired without a value writes
+// `undefined` into state". A node may legitimately be configured without an
+// explicit value (e.g. the admin "Close Detail Panel" workflow clearing an id).
+// The client runtime must then fall back to the state type's empty default —
+// string -> '', array -> [], object -> {}, anything else -> null — so a setter
+// never receives `undefined` (which flips a controlled input to uncontrolled).
+//
+// `__stateUpdateHandler` / `__defaultValueForType` / the `state-batch-update`
+// handler all live inside the page-level `__createWorkflowHandlers` factory
+// emitted by the workflow component plugin (and only the trigger surface is
+// returned, not the handler map). We can't import them directly, so we pull the
+// individual function sources out of the generated module-level code and
+// reconstitute them in a sandbox with the closure variables they rely on (same
+// approach as state-setter-value-key-unwrap.test.ts).
+
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+// Brace-match a `function NAME(...) { ... }` declaration out of generated code.
+const extractFunctionSource = (haystack: string, funcDecl: string): string => {
+  const startIdx = haystack.indexOf(funcDecl)
+  if (startIdx === -1) {
+    throw new Error('Helper not found: ' + funcDecl)
+  }
+  return braceMatchFrom(haystack, startIdx)
+}
+
+// Brace-match the `function(...) { ... }` expression assigned to a given LHS,
+// e.g. `__handlers['state-batch-update'] = function(config, context) { ... }`.
+const extractAssignedFunction = (haystack: string, lhs: string): string => {
+  const lhsIdx = haystack.indexOf(lhs)
+  if (lhsIdx === -1) {
+    throw new Error('Assignment not found: ' + lhs)
+  }
+  const fnIdx = haystack.indexOf('function', lhsIdx)
+  if (fnIdx === -1) {
+    throw new Error('No function expression after ' + lhs)
+  }
+  return braceMatchFrom(haystack, fnIdx)
+}
+
+const braceMatchFrom = (haystack: string, startIdx: number): string => {
+  let depth = 0
+  let i = haystack.indexOf('{', startIdx)
+  if (i === -1) {
+    throw new Error('No opening brace from index ' + startIdx)
+  }
+  for (; i < haystack.length; i++) {
+    const ch = haystack.charAt(i)
+    if (ch === '{') {
+      depth++
+    } else if (ch === '}') {
+      depth--
+      if (depth === 0) {
+        return haystack.slice(startIdx, i + 1)
+      }
+    }
+  }
+  throw new Error('Unbalanced braces from index ' + startIdx)
+}
+
+const buildStructure = (): any => {
+  const triggerNodeId = 'trigger-1'
+  const stateUpdateNodeId = 'update-1'
+  const workflow = {
+    id: 'wf-1',
+    name: 'Test WF',
+    trigger: {
+      type: 'event-page-loaded',
+      nodeId: triggerNodeId,
+      scope: 'page',
+      config: { pageId: 'page-1' },
+    },
+    nodes: [
+      {
+        id: stateUpdateNodeId,
+        type: 'state-update-local-state',
+        config: { property: 'myStr', value: 'x' },
+        stepNumber: 1,
+        label: 'X',
+      },
+    ],
+    edges: [{ id: 'e', source: triggerNodeId, target: stateUpdateNodeId }],
+  }
+  return {
+    uidl: {
+      name: 'Page',
+      outputOptions: { pageId: 'page-1', fileName: 'page-1' },
+      node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+      stateDefinitions: {
+        myStr: { type: 'string', defaultValue: '' },
+        myObj: { type: 'object', defaultValue: {} },
+      },
+    },
+    chunks: [
+      {
+        type: 'chunk-type-ast',
+        name: 'jsx-component',
+        content: {
+          type: 'VariableDeclaration',
+          declarations: [
+            {
+              type: 'VariableDeclarator',
+              init: {
+                type: 'ArrowFunctionExpression',
+                body: {
+                  type: 'BlockStatement',
+                  body: [{ type: 'ReturnStatement', argument: null }],
+                },
+              },
+            },
+          ],
+        },
+      },
+    ],
+    options: {
+      workflows: { workflows: { 'wf-1': workflow }, customNodes: {} },
+    },
+    dependencies: {},
+  }
+}
+
+type HandlerFn = (config: any, context: any) => Promise<any>
+
+interface Runtime {
+  update: HandlerFn
+  batch: HandlerFn
+  defaultForType: (type: string | undefined) => unknown
+  writes: Record<string, unknown>
+  hasWrite: (prop: string) => boolean
+}
+
+let cachedModuleCode: string | null = null
+
+const getModuleCode = async (): Promise<string> => {
+  if (cachedModuleCode) {
+    return cachedModuleCode
+  }
+  const plugin = createNextWorkflowPlugin({ isPage: true })
+  const structure = buildStructure()
+  await plugin(structure as any)
+  const moduleChunk = (structure.chunks as any[]).find((c: any) => c.name === 'workflow-module')
+  if (!moduleChunk) {
+    throw new Error('workflow-module chunk not emitted by plugin')
+  }
+  cachedModuleCode = String(moduleChunk.content)
+  return cachedModuleCode
+}
+
+// Reconstitute the state-update runtime (handler + helpers) in a sandbox,
+// wiring spying setters so we can assert what value each update writes.
+const buildRuntime = async (stateTypes: Record<string, string>): Promise<Runtime> => {
+  const moduleCode = await getModuleCode()
+  const coerceSrc = extractFunctionSource(moduleCode, 'function __coerceValue')
+  const defaultSrc = extractFunctionSource(moduleCode, 'function __defaultValueForType')
+  const updateSrc = extractFunctionSource(moduleCode, 'function __stateUpdateHandler')
+  const batchSrc = extractAssignedFunction(moduleCode, "__handlers['state-batch-update']")
+
+  const writes: Record<string, unknown> = {}
+  const written = new Set<string>()
+  const stateSetters: Record<string, (v: unknown) => void> = {}
+  for (const key of Object.keys(stateTypes)) {
+    stateSetters[key] = (v: unknown) => {
+      writes[key] = v
+      written.add(key)
+    }
+  }
+  const stateValuesRef = { current: {} as Record<string, unknown> }
+
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  const factory = new Function(
+    'stateSetters',
+    'stateTypes',
+    'stateValuesRef',
+    'refreshGlobalState',
+    `
+    var __stateNameMap = {};
+    var __setterKeys = Object.keys(stateSetters);
+    for (var __i = 0; __i < __setterKeys.length; __i++) {
+      __stateNameMap[__setterKeys[__i]] = __setterKeys[__i];
+      var __snake = __setterKeys[__i].replace(/[A-Z]/g, function(l) { return '_' + l.toLowerCase(); });
+      if (__snake !== __setterKeys[__i]) __stateNameMap[__snake] = __setterKeys[__i];
+    }
+    function __resolveName(name) { return __stateNameMap[name] || name; }
+    ${coerceSrc}
+    ${defaultSrc}
+    ${updateSrc}
+    var __batch = ${batchSrc};
+    return { update: __stateUpdateHandler, batch: __batch, defaultForType: __defaultValueForType };
+    `
+  )
+  const rt = factory(stateSetters, stateTypes, stateValuesRef, undefined)
+  return {
+    update: rt.update,
+    batch: rt.batch,
+    defaultForType: rt.defaultForType,
+    writes,
+    hasWrite: (prop: string) => written.has(prop),
+  }
+}
+
+const STATE_TYPES = {
+  myStr: 'string',
+  myArr: 'array',
+  myObj: 'object',
+  myNum: 'number',
+  myBool: 'boolean',
+}
+
+describe('__defaultValueForType mapping', () => {
+  it('maps each state type to its empty default', async () => {
+    const rt = await buildRuntime(STATE_TYPES)
+    expect(rt.defaultForType('string')).toBe('')
+    expect(rt.defaultForType('array')).toEqual([])
+    expect(rt.defaultForType('object')).toEqual({})
+    expect(rt.defaultForType('number')).toBeNull()
+    expect(rt.defaultForType('boolean')).toBeNull()
+    expect(rt.defaultForType(undefined)).toBeNull()
+  })
+})
+
+describe('state-update without a value defaults by state type', () => {
+  it("defaults a string state to ''", async () => {
+    const rt = await buildRuntime(STATE_TYPES)
+    await rt.update({ property: 'myStr' }, { __stateValues: {} })
+    expect(rt.writes.myStr).toBe('')
+  })
+
+  it('defaults an array state to []', async () => {
+    const rt = await buildRuntime(STATE_TYPES)
+    await rt.update({ property: 'myArr' }, { __stateValues: {} })
+    expect(rt.writes.myArr).toEqual([])
+  })
+
+  it('defaults an object state to {}', async () => {
+    const rt = await buildRuntime(STATE_TYPES)
+    await rt.update({ property: 'myObj' }, { __stateValues: {} })
+    expect(rt.writes.myObj).toEqual({})
+  })
+
+  it('defaults number and boolean states to null', async () => {
+    const rt = await buildRuntime(STATE_TYPES)
+    await rt.update({ property: 'myNum' }, { __stateValues: {} })
+    await rt.update({ property: 'myBool' }, { __stateValues: {} })
+    expect(rt.writes.myNum).toBeNull()
+    expect(rt.writes.myBool).toBeNull()
+  })
+
+  it('preserves an explicit null (a real value — only a missing value defaults)', async () => {
+    // A dynamic binding can resolve to null at runtime; defaulting it (e.g.
+    // object -> {}) would flip downstream truthiness checks. Only a statically
+    // absent value (config.value === undefined) is treated as "not set".
+    const rt = await buildRuntime(STATE_TYPES)
+    await rt.update({ property: 'myStr', value: null }, { __stateValues: {} })
+    expect(rt.writes.myStr).toBeNull()
+  })
+
+  it('preserves an explicit value (no defaulting)', async () => {
+    const rt = await buildRuntime(STATE_TYPES)
+    await rt.update({ property: 'myStr', value: 'hello' }, { __stateValues: {} })
+    expect(rt.writes.myStr).toBe('hello')
+  })
+
+  it('defaults unset entries in a batch update too', async () => {
+    const rt = await buildRuntime(STATE_TYPES)
+    await rt.batch(
+      {
+        updates: [{ key: 'myStr' }, { key: 'myArr', value: undefined }, { key: 'myNum', value: 7 }],
+      },
+      { __stateValues: {} }
+    )
+    expect(rt.writes.myStr).toBe('')
+    expect(rt.writes.myArr).toEqual([])
+    expect(rt.writes.myNum).toBe(7)
+  })
+
+  it('does NOT default a property-mode update (sub-property stays undefined)', async () => {
+    // Object property-mode updates set a single key; an unset value there means
+    // "clear this property", not "replace the object with its type default".
+    const rt = await buildRuntime(STATE_TYPES)
+    await rt.update(
+      { property: 'myObj', objectUpdateMode: 'property', objectPropertyPath: 'a' },
+      { __stateValues: { myObj: { a: 1 } } }
+    )
+    expect(rt.writes.myObj).toEqual({ a: undefined })
+  })
+})

package/__tests__/transform-generate-output.test.ts

@@ -0,0 +1,47 @@
+/* tslint:disable:no-eval */
+import { transformGenerate } from '../src/nodes/transform/transform-generate'
+
+// Regression: the password-reset (and booking) workflow builders, and the
+// node-context-schemas contract, all read transform-generate's output as
+// `.value` ({ value, type, timestamp }). The node previously returned
+// `{ result }`, so `.value` was undefined — which inserted NULL into the
+// NOT-NULL `password_reset_tokens.token` column ("null value in column token
+// ... violates not-null constraint"). The node must honour its declared
+// output contract.
+
+function evalHandler(): any {
+  return eval('(' + transformGenerate.generateHandler() + ')')
+}
+
+describe('transform-generate output contract', () => {
+  it('returns the generated value under `.value` (contract: { value, type, timestamp })', async () => {
+    const handler = evalHandler()
+    const out = await handler({ generateType: 'uuid' }, {})
+    expect(typeof out.value).toBe('string')
+    expect(out.value).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+    )
+    expect(out.type).toBe('uuid')
+    expect(typeof out.timestamp).toBe('number')
+    // `result` retained as a defensive alias so nothing that read it breaks.
+    expect(out.result).toBe(out.value)
+  })
+
+  it('exposes `.value` for every generate type (random-string, random-number, timestamp)', async () => {
+    const handler = evalHandler()
+    const s = await handler({ generateType: 'random-string', length: 10 }, {})
+    expect(typeof s.value).toBe('string')
+    expect(s.value.length).toBe(10)
+    const n = await handler({ generateType: 'random-number', min: 1, max: 5 }, {})
+    expect(typeof n.value).toBe('number')
+    const t = await handler({ generateType: 'timestamp' }, {})
+    expect(typeof t.value).toBe('number')
+  })
+
+  it('error paths still expose `.value: null` (never undefined)', async () => {
+    const handler = evalHandler()
+    const out = await handler({ generateType: 'no-such-type' }, {})
+    expect(out.value).toBeNull()
+    expect(out.error).toContain('Unknown generate type')
+  })
+})

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,MAovBjD,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MAsY5C,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,MAovBjD,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MAsc5C,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MAK5C,CAAA"}

package/dist/cjs/executor-generator.js

@@ -762,6 +762,39 @@ exports.generateSharedRuntimeUtilsCode = generateSharedRuntimeUtilsCode;
 const generateClientRuntimeCode = () => {
     return `const utils = require('./runtime-utils');
 
+// A live DOM element (the workflow trigger element) cannot cross the network
+// to a server segment — JSON.stringify throws on its circular references, so it
+// used to prune down to { __serializationError: true }. That dropped the
+// element's dataset, which server nodes rely on (e.g. a cart "+" button whose
+// data-select filters products by trigger.element.dataset.productId, or a
+// cart-update node reading trigger.element.dataset.cartItemId). We replace any
+// DOM node with a serializable snapshot carrying its dataset + form value, so
+// those reads keep resolving on both sides of the round-trip.
+function isDomNode(v) {
+  return !!v && typeof v === 'object' && typeof v.nodeType === 'number' && v.nodeType === 1;
+}
+
+function snapshotDomNode(el) {
+  var snap = { __domSnapshot: true, dataset: {} };
+  try { snap.tagName = el.tagName || null; } catch (e) {}
+  try { snap.id = el.id || ''; } catch (e) {}
+  try { snap.name = el.name || ''; } catch (e) {}
+  try { snap.type = el.type || ''; } catch (e) {}
+  try { snap.className = typeof el.className === 'string' ? el.className : ''; } catch (e) {}
+  try { if ('value' in el) snap.value = el.value; } catch (e) {}
+  try { if ('checked' in el) snap.checked = el.checked; } catch (e) {}
+  try {
+    if (el.dataset) {
+      for (var k in el.dataset) { snap.dataset[k] = el.dataset[k]; }
+    }
+  } catch (e) {}
+  return snap;
+}
+
+function domSerializationReplacer(key, value) {
+  return isDomNode(value) ? snapshotDomNode(value) : value;
+}
+
 function pruneContext(context) {
   const pruned = {};
   const keys = Object.keys(context);
@@ -771,11 +804,15 @@ function pruneContext(context) {
     if (val === undefined || val === null) continue;
     if (typeof val === 'function') continue;
     try {
-      const serialized = JSON.stringify(val);
+      // Replace DOM nodes with serializable snapshots as we stringify, then
+      // re-parse so the request body itself (JSON.stringify(prunedContext) in
+      // callServerSegment, which has no replacer) never sees a live DOM node.
+      const serialized = JSON.stringify(val, domSerializationReplacer);
+      if (serialized === undefined) continue;
       if (serialized.length > 100000) {
         pruned[key] = { __truncated: true, type: typeof val };
       } else {
-        pruned[key] = val;
+        pruned[key] = JSON.parse(serialized);
       }
     } catch(e) {
       pruned[key] = { __serializationError: true };
@@ -784,6 +821,36 @@ function pruneContext(context) {
   return pruned;
 }
 
+// Merge a server segment's returned context back into the live client context.
+// Two rules protect client-only state that cannot survive the round-trip:
+//   1. A server-side placeholder ({ __serializationError } / { __truncated })
+//      must never overwrite a real client value.
+//   2. The trigger element/node is authoritative on the client. The live DOM
+//      element is sent to the server as a snapshot (see pruneContext) and
+//      echoed back as that snapshot; keeping the client's real element means a
+//      post-server client node (cart-update reading
+//      trigger.element.dataset.cartItemId, or any node calling a DOM method)
+//      still works against the genuine element rather than a frozen copy.
+function mergeServerResults(context, serverResults, triggerNodeId) {
+  if (!serverResults || typeof serverResults !== 'object') return;
+  const keys = Object.keys(serverResults);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const clientVal = context[key];
+    // Keep the client's authoritative live DOM trigger element. The top-level
+    // triggerElement holds the node directly; the trigger node's context holds
+    // it under .element. The generic .element guard also covers the trigger
+    // node id even when it is not passed in (e.g. inside a custom node).
+    if (key === 'triggerElement' && isDomNode(clientVal)) continue;
+    if (triggerNodeId && key === triggerNodeId && clientVal && isDomNode(clientVal.element)) continue;
+    if (clientVal && typeof clientVal === 'object' && isDomNode(clientVal.element)) continue;
+    const val = serverResults[key];
+    // A server-side serialization placeholder must never clobber a real value.
+    if (val && typeof val === 'object' && (val.__serializationError === true || val.__truncated === true)) continue;
+    context[key] = val;
+  }
+}
+
 // Absolutizes a workflow-segment URL for server-side execution.
 //
 // Custom nodes are generated once and shared between client and server
@@ -942,10 +1009,7 @@ async function callStreamingServerSegment(segmentUrl, context, streamingInfo, al
         context[data.nodeId] = data.result;
       } else if (data.type === 'done') {
         if (data.results) {
-          const rKeys = Object.keys(data.results);
-          for (let rk = 0; rk < rKeys.length; rk++) {
-            context[rKeys[rk]] = data.results[rKeys[rk]];
-          }
+          mergeServerResults(context, data.results, workflowConfig && workflowConfig.triggerNodeId);
         }
         const streamedKeys = Object.keys(streamedNodeIds);
         for (let sk = 0; sk < streamedKeys.length; sk++) {
@@ -1038,7 +1102,7 @@ async function executeWorkflowWithSegments(workflowConfig, triggerContext, clien
           const url = serverSegmentUrls[seg.id];
           if (!url) throw new Error('No server URL for segment: ' + seg.id);
           const serverResults = await callServerSegment(url, context);
-          if (serverResults) Object.assign(context, serverResults);
+          mergeServerResults(context, serverResults, workflowConfig.triggerNodeId);
           var segNodes = seg.nodes;
           if (segNodes && segNodes.length > 0 && serverResults) {
             var sortedSeg = segNodes.slice().sort(function(a, b) {
@@ -1147,7 +1211,7 @@ async function executeWorkflowWithSegments(workflowConfig, triggerContext, clien
   return context;
 }
 
-module.exports = { executeWorkflowWithSegments, callServerSegment, callStreamingServerSegment, findStreamingAINodes };
+module.exports = { executeWorkflowWithSegments, callServerSegment, callStreamingServerSegment, mergeServerResults, findStreamingAINodes };
 `;
 };
 exports.generateClientRuntimeCode = generateClientRuntimeCode;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkvBR,CAAA;AACD,CAAC,CAAA;AApvBY,QAAA,8BAA8B,kCAovB1C;AAEM,MAAM,yBAAyB,GAAG,GAAW,EAAE;IACpD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoYR,CAAA;AACD,CAAC,CAAA;AAtYY,QAAA,yBAAyB,6BAsYrC;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkvBR,CAAA;AACD,CAAC,CAAA;AApvBY,QAAA,8BAA8B,kCAovB1C;AAEM,MAAM,yBAAyB,GAAG,GAAW,EAAE;IACpD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAocR,CAAA;AACD,CAAC,CAAA;AAtcY,QAAA,yBAAyB,6BAscrC;AAEM,MAAM,yBAAyB,GAAG,GAAW,EAAE;IACpD,OAAO;;;CAGR,CAAA;AACD,CAAC,CAAA;AALY,QAAA,yBAAyB,6BAKrC"}

package/dist/cjs/nodes/account/account-compare-passwords.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"account-compare-passwords.d.ts","sourceRoot":"","sources":["../../../../src/nodes/account/account-compare-passwords.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AA+ChE,eAAO,MAAM,uBAAuB,EAAE,oBASrC,CAAA"}
+{"version":3,"file":"account-compare-passwords.d.ts","sourceRoot":"","sources":["../../../../src/nodes/account/account-compare-passwords.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AAiDhE,eAAO,MAAM,uBAAuB,EAAE,oBASrC,CAAA"}

package/dist/cjs/nodes/account/account-compare-passwords.js

@@ -35,7 +35,9 @@ async function account_compare_passwords(config, context) {
         .update(passwordStr + PEPPER)
         .digest('base64');
     const isMatch = bcrypt.compareSync(sha, hashStr);
-    return { isMatch };
+    // `isMatch` is the contract key; `match` is a defensive alias for any
+    // workflow that reads `.match` (the delete-account template did).
+    return { isMatch, match: isMatch };
 }
 exports.accountComparePasswords = {
     nodeType: 'account-compare-passwords',

package/dist/cjs/nodes/account/account-compare-passwords.js.map

@@ -1 +1 @@
-{"version":3,"file":"account-compare-passwords.js","sourceRoot":"","sources":["../../../../src/nodes/account/account-compare-passwords.ts"],"names":[],"mappings":";;;AAAA,oCAAgE;AAEhE,KAAK,UAAU,yBAAyB,CAAC,MAAW,EAAE,OAAgC;IACpF,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAA;IAChC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAA;IAExB,IAAI,CAAC,QAAQ,IAAI,QAAQ,KAAK,EAAE,EAAE;QAChC,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAA;KACxC;IAED,IAAI,CAAC,IAAI,EAAE;QACT,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAA;KACpC;IAED,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IACpC,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAE5B,IAAI,WAAW,CAAC,MAAM,GAAG,IAAI,EAAE;QAC7B,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;KACnD;IAED,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;QACxB,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAA;KACxC;IAED,yEAAyE;IACzE,mEAAmE;IACnE,2EAA2E;IAC3E,4EAA4E;IAC5E,4EAA4E;IAC5E,uEAAuE;IACvE,oEAAoE;IACpE,MAAM,aAAa,GACjB,OAAO,uBAAuB,KAAK,WAAW,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,OAAO,CAAA;IACpF,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,CAAA;IACxC,MAAM,MAAM,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAA;IAEtC,MAAM,MAAM,GAAI,UAAkB,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,EAAE,CAAA;IAChE,MAAM,GAAG,GAAG,MAAM;SACf,UAAU,CAAC,QAAQ,CAAC;SACpB,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC;SAC5B,MAAM,CAAC,QAAQ,CAAC,CAAA;IACnB,MAAM,OAAO,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;IAEhD,OAAO,EAAE,OAAO,EAAE,CAAA;AACpB,CAAC;AAEY,QAAA,uBAAuB,GAAyB;IAC3D,QAAQ,EAAE,2BAA2B;IACrC,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE;QACZ,QAAQ,EAAE,QAAQ;KACnB;IACD,eAAe;QACb,OAAO,IAAA,uBAAe,EAAC,yBAAyB,CAAC,CAAA;IACnD,CAAC;CACF,CAAA"}
+{"version":3,"file":"account-compare-passwords.js","sourceRoot":"","sources":["../../../../src/nodes/account/account-compare-passwords.ts"],"names":[],"mappings":";;;AAAA,oCAAgE;AAEhE,KAAK,UAAU,yBAAyB,CAAC,MAAW,EAAE,OAAgC;IACpF,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAA;IAChC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAA;IAExB,IAAI,CAAC,QAAQ,IAAI,QAAQ,KAAK,EAAE,EAAE;QAChC,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAA;KACxC;IAED,IAAI,CAAC,IAAI,EAAE;QACT,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAA;KACpC;IAED,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IACpC,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;IAE5B,IAAI,WAAW,CAAC,MAAM,GAAG,IAAI,EAAE;QAC7B,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;KACnD;IAED,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;QACxB,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAA;KACxC;IAED,yEAAyE;IACzE,mEAAmE;IACnE,2EAA2E;IAC3E,4EAA4E;IAC5E,4EAA4E;IAC5E,uEAAuE;IACvE,oEAAoE;IACpE,MAAM,aAAa,GACjB,OAAO,uBAAuB,KAAK,WAAW,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,OAAO,CAAA;IACpF,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,CAAA;IACxC,MAAM,MAAM,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAA;IAEtC,MAAM,MAAM,GAAI,UAAkB,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,EAAE,CAAA;IAChE,MAAM,GAAG,GAAG,MAAM;SACf,UAAU,CAAC,QAAQ,CAAC;SACpB,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC;SAC5B,MAAM,CAAC,QAAQ,CAAC,CAAA;IACnB,MAAM,OAAO,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;IAEhD,sEAAsE;IACtE,kEAAkE;IAClE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA;AACpC,CAAC;AAEY,QAAA,uBAAuB,GAAyB;IAC3D,QAAQ,EAAE,2BAA2B;IACrC,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE;QACZ,QAAQ,EAAE,QAAQ;KACnB;IACD,eAAe;QACb,OAAO,IAAA,uBAAe,EAAC,yBAAyB,CAAC,CAAA;IACnD,CAAC;CACF,CAAA"}

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;AA8ChE,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;AAiEhE,eAAO,MAAM,iBAAiB,EAAE,oBAS/B,CAAA"}

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

@@ -4,6 +4,25 @@ exports.accountGetCurrent = void 0;
 const types_1 = require("../types");
 async function account_get_current(_config, context) {
     const baseUrl = (context && context.__baseUrl) || '';
+    // The declared output contract (node-context-schemas) exposes the user's
+    // fields at the TOP LEVEL (id, email, name, image, ...). Workflow builders
+    // read e.g. `wfCtx(node, ['id'])` for a row's user_id, and the AI reads the
+    // flat fields too. Emit the user's fields flat AND keep a `user` object for
+    // anything that reads `.user`.
+    // Copy the user's fields onto a fresh object (no Object.assign/spread — this
+    // handler is .toString()'d and bundled, where down-levelled spread would
+    // reference a tslib helper that doesn't exist at runtime).
+    const __out = (user) => {
+        const o = {};
+        if (user) {
+            const ks = Object.keys(user);
+            for (let i = 0; i < ks.length; i++) {
+                o[ks[i]] = user[ks[i]];
+            }
+        }
+        o.user = user || null;
+        return o;
+    };
     try {
         const response = await fetch(baseUrl + '/api/auth/session');
         if (response.ok) {
@@ -20,25 +39,25 @@ async function account_get_current(_config, context) {
                 }
                 catch (_e) { }
             }
-            return { user };
+            return __out(user);
         }
         if (typeof window !== 'undefined') {
             try {
                 const cached = window.localStorage.getItem('teleport_auth_user');
                 if (cached) {
-                    return { user: JSON.parse(cached) };
+                    return __out(JSON.parse(cached));
                 }
             }
             catch (_e) { }
         }
-        return { user: null };
+        return __out(null);
     }
     catch (err) {
         if (typeof window !== 'undefined') {
             try {
                 const fallback = window.localStorage.getItem('teleport_auth_user');
                 if (fallback) {
-                    return { user: JSON.parse(fallback) };
+                    return __out(JSON.parse(fallback));
                 }
             }
             catch (_e) { }

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":";;;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,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,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;gBACjC,IAAI;oBACF,IAAI,IAAI,EAAE;wBACR,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,oBAAoB,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAA;qBACxE;yBAAM;wBACL,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,oBAAoB,CAAC,CAAA;qBACrD;iBACF;gBAAC,OAAO,EAAE,EAAE,GAAE;aAChB;YAED,OAAO,EAAE,IAAI,EAAE,CAAA;SAChB;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,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAA;iBACpC;aACF;YAAC,OAAO,EAAE,EAAE,GAAE;SAChB;QAED,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;KACtB;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,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAA;iBACtC;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"}
+{"version":3,"file":"account-get-current.js","sourceRoot":"","sources":["../../../../src/nodes/account/account-get-current.ts"],"names":[],"mappings":"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"}

package/dist/cjs/nodes/account/account-login.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"account-login.d.ts","sourceRoot":"","sources":["../../../../src/nodes/account/account-login.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AA6DhE,eAAO,MAAM,YAAY,EAAE,oBAqC1B,CAAA"}
+{"version":3,"file":"account-login.d.ts","sourceRoot":"","sources":["../../../../src/nodes/account/account-login.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AAyEhE,eAAO,MAAM,YAAY,EAAE,oBAmC1B,CAAA"}

package/dist/cjs/nodes/account/account-login.js

@@ -52,7 +52,19 @@ async function account_login(config, context) {
         window.dispatchEvent(new CustomEvent('teleport:auth-user-changed', { detail: { user } }));
         window.location.href = '/';
     }
-    return { user, success: true };
+    // Contract exposes user fields flat (id, email, name, ...) plus `user`/`success`.
+    // Built without Object.assign/spread — this handler is .toString()'d and
+    // bundled, where down-levelled spread would reference a missing tslib helper.
+    const __out = {};
+    if (user) {
+        const __k = Object.keys(user);
+        for (let __i = 0; __i < __k.length; __i++) {
+            __out[__k[__i]] = user[__k[__i]];
+        }
+    }
+    __out.user = user || null;
+    __out.success = true;
+    return __out;
 }
 exports.accountLogin = {
     nodeType: 'account-login',
@@ -85,10 +97,8 @@ exports.accountLogin = {
     throw new Error('Invalid email or password');
   }
 
-  return {
-    user: authUtils.sanitizeUser(user),
-    success: true,
-  };
+  const __su = authUtils.sanitizeUser(user);
+  return Object.assign({}, __su || {}, { user: __su, success: true });
 }`;
     },
 };

package/dist/cjs/nodes/account/account-login.js.map

@@ -1 +1 @@
-{"version":3,"file":"account-login.js","sourceRoot":"","sources":["../../../../src/nodes/account/account-login.ts"],"names":[],"mappings":";;;AAAA,oCAAgE;AAEhE,KAAK,UAAU,aAAa,CAAC,MAAW,EAAE,OAAgC;IACxE,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAA;IAC1B,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAA;IAEhC,IAAI,CAAC,KAAK,IAAI,CAAC,QAAQ,EAAE;QACvB,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;KACnD;IAED,wEAAwE;IACxE,4EAA4E;IAC5E,wEAAwE;IACxE,2EAA2E;IAC3E,4EAA4E;IAC5E,uEAAuE;IACvE,uEAAuE;IACvE,2EAA2E;IAC3E,yEAAyE;IACzE,yEAAyE;IACzE,sEAAsE;IACtE,MAAM,aAAa,GACjB,CAAC,OAAO,MAAM,KAAK,WAAW,IAAK,MAAc,CAAC,kBAAkB,CAAC,IAAI,IAAI,CAAA;IAC/E,IAAI,CAAC,aAAa,IAAI,OAAO,aAAa,CAAC,MAAM,KAAK,UAAU,EAAE;QAChE,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAA;KAClF;IACD,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,CAAA;IAEnC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,aAAa,EAAE;QACzC,KAAK;QACL,QAAQ;QACR,QAAQ,EAAE,KAAK;KAChB,CAAC,CAAA;IAEF,IAAI,MAAM,IAAI,MAAM,CAAC,KAAK,EAAE;QAC1B,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;KAC9B;IAED,IAAI,IAAI,GAAG,IAAI,CAAA;IACf,IAAI;QACF,MAAM,OAAO,GAAG,CAAC,OAAO,IAAK,OAAe,CAAC,SAAS,CAAC,IAAI,EAAE,CAAA;QAC7D,MAAM,UAAU,GAAG,MAAM,KAAK,CAAC,OAAO,GAAG,mBAAmB,CAAC,CAAA;QAC7D,IAAI,UAAU,CAAC,EAAE,EAAE;YACjB,MAAM,OAAO,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,CAAA;YACvC,IAAI,GAAG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAA;SACrD;KACF;IAAC,OAAO,EAAE,EAAE,GAAE;IAEf,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;QACjC,IAAI,IAAI,EAAE;YACR,IAAI;gBACF,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,oBAAoB,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAA;aACxE;YAAC,OAAO,EAAE,EAAE,GAAE;SAChB;QACD,MAAM,CAAC,aAAa,CAAC,IAAI,WAAW,CAAC,4BAA4B,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAA;QACzF,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,GAAG,CAAA;KAC3B;IAED,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA;AAChC,CAAC;AAEY,QAAA,YAAY,GAAyB;IAChD,QAAQ,EAAE,eAAe;IACzB,YAAY,EAAE,QAAQ;IACtB,YAAY,EAAE;QACZ,WAAW,EAAE,SAAS;KACvB;IACD,eAAe;QACb,OAAO,IAAA,uBAAe,EAAC,aAAa,CAAC,CAAA;IACvC,CAAC;IACD,qBAAqB;QACnB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;EAyBT,CAAA;IACA,CAAC;CACF,CAAA"}
+{"version":3,"file":"account-login.js","sourceRoot":"","sources":["../../../../src/nodes/account/account-login.ts"],"names":[],"mappings":"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"}

package/dist/cjs/nodes/account/account-signup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"account-signup.d.ts","sourceRoot":"","sources":["../../../../src/nodes/account/account-signup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AA8EhE,eAAO,MAAM,aAAa,EAAE,oBAgE3B,CAAA"}
+{"version":3,"file":"account-signup.d.ts","sourceRoot":"","sources":["../../../../src/nodes/account/account-signup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAmB,MAAM,UAAU,CAAA;AA0FhE,eAAO,MAAM,aAAa,EAAE,oBA8D3B,CAAA"}