@teleporthq/teleport-plugin-next-workflows 0.43.61 → 0.43.63

package/__tests__/custom-event-component-scope.test.ts

@@ -0,0 +1,143 @@
+// A custom-event workflow bound to a component must be emitted INTO that
+// component, not into the global workflow module.
+//
+// This is what makes the AI chat's dictation work: the transcript arrives as a
+// custom event, and the workflow that consumes it writes `chatInputValue` — a
+// component-local state. A global workflow is emitted into a module that owns no
+// state setters, so that write would warn and no-op, and the field would never
+// fill in. The routing below is the guarantee that cannot happen.
+
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+const customEventWorkflow = (config: Record<string, unknown>, scope: string) => ({
+  id: 'wf-dictation-result',
+  name: 'Insert Dictated Chat Text',
+  trigger: {
+    type: 'event-custom-triggered',
+    nodeId: 'trigger-custom-event',
+    scope,
+    config,
+  },
+  nodes: [
+    {
+      id: 'update-1',
+      type: 'state-update-local-state',
+      config: {
+        property: 'chatInputValue',
+        value: {
+          type: 'workflowContext',
+          nodeId: 'trigger-custom-event',
+          path: ['trigger-custom-event', 'eventData', 'text'],
+        },
+      },
+      stepNumber: 1,
+      label: 'Store Dictated Text',
+    },
+  ],
+  edges: [{ id: 'e1', source: 'trigger-custom-event', target: 'update-1' }],
+})
+
+// `any` because the chunk is a hand-written Babel AST fragment, not a value
+// produced by @babel/types' builders.
+const jsxComponentChunk = (): any => ({
+  type: 'chunk-type-ast',
+  name: 'jsx-component',
+  content: {
+    type: 'VariableDeclaration',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'ArrowFunctionExpression',
+          body: { type: 'BlockStatement', body: [{ type: 'ReturnStatement', argument: null }] },
+        },
+      },
+    ],
+  },
+})
+
+const getWorkflowModule = async (
+  uidl: Record<string, unknown>,
+  workflow: any,
+  isPage: boolean
+): Promise<string | null> => {
+  const plugin = createNextWorkflowPlugin({ isPage })
+  const structure: any = {
+    uidl: {
+      node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+      stateDefinitions: { chatInputValue: { type: 'string', defaultValue: '' } },
+      ...uidl,
+    },
+    chunks: [jsxComponentChunk()],
+    options: {
+      workflows: { workflows: { [workflow.id]: workflow }, customNodes: {} },
+    },
+    dependencies: {},
+  }
+  await plugin(structure)
+  const moduleChunk = (structure.chunks as any[]).find((c: any) => c.name === 'workflow-module')
+  return moduleChunk ? String(moduleChunk.content) : null
+}
+
+describe('component-scoped custom-event workflows', () => {
+  it('registers the listener inside the component it is bound to', async () => {
+    const code = await getWorkflowModule(
+      { name: 'ai-assistant-chat' },
+      customEventWorkflow(
+        {
+          eventName: 'ai-chat-dictation-result',
+          componentId: 'TQ_chat',
+          componentName: 'ai-assistant-chat',
+        },
+        'component'
+      ),
+      false
+    )
+    expect(code).not.toBeNull()
+    expect(code).toContain('workflow:custom:ai-chat-dictation-result')
+    // Registered on mount and torn down on unmount, like every other
+    // component-scoped listener.
+    expect(code).toContain('removeEventListener')
+  })
+
+  it('does NOT leak into an unrelated component', async () => {
+    const code = await getWorkflowModule(
+      { name: 'Footer' },
+      customEventWorkflow(
+        {
+          eventName: 'ai-chat-dictation-result',
+          componentId: 'TQ_chat',
+          componentName: 'ai-assistant-chat',
+        },
+        'component'
+      ),
+      false
+    )
+    expect(code).toBeNull()
+  })
+
+  it('does NOT leak into pages', async () => {
+    const code = await getWorkflowModule(
+      { name: 'ai-assistant-chat', outputOptions: { pageId: 'page-1', fileName: 'home' } },
+      customEventWorkflow(
+        {
+          eventName: 'ai-chat-dictation-result',
+          componentId: 'TQ_chat',
+          componentName: 'ai-assistant-chat',
+        },
+        'component'
+      ),
+      true
+    )
+    expect(code).toBeNull()
+  })
+
+  it('leaves an unbound (global-scoped) custom-event workflow out of the component', async () => {
+    const code = await getWorkflowModule(
+      { name: 'ai-assistant-chat' },
+      customEventWorkflow({ eventName: 'order-placed' }, 'global'),
+      false
+    )
+    expect(code).toBeNull()
+  })
+})

package/__tests__/data-update-item-runtime.test.ts

@@ -99,6 +99,45 @@ describe('data-update-item runtime output + null-safety', () => {
     expect(result.affected).toBe(0)
   })
 
+  /*
+    A value that could not cross the client→server hand-off arrives as the
+    pruner's placeholder. Written through, it REPLACES the stored content with
+    `{"__truncated":true}` — which is how a rich-text field carrying an inlined
+    image emptied a whole custom page's block tree. The column keeps what it has
+    instead, exactly like an undefined mapping.
+  */
+  it('keeps the stored value when the new one arrived truncated', async () => {
+    const calls = installFetch({ id: 'r1', updatedCount: 1 })
+    await handler(
+      {
+        tableName: 'teleport_pages',
+        filters: [{ field: 'id', operator: '=', value: 'p1' }],
+        columnMappings: [
+          { column: 'blocks', value: { __truncated: true, type: 'string' } },
+          { column: 'title', value: 'Launch' },
+        ],
+      },
+      {}
+    )
+    expect(calls).toHaveLength(1)
+    const sentMappings = calls[0].body.columnMappings as Array<{ column: string }>
+    expect(sentMappings.map((m) => m.column)).toEqual(['title'])
+  })
+
+  it('keeps the stored value when the new one could not be serialized', async () => {
+    const calls = installFetch({ id: 'r1', updatedCount: 1 })
+    const result = (await handler(
+      {
+        tableName: 'teleport_pages',
+        filters: [{ field: 'id', operator: '=', value: 'p1' }],
+        columnMappings: { blocks: { __serializationError: true } },
+      },
+      {}
+    )) as Record<string, unknown>
+    expect(calls).toHaveLength(0)
+    expect(result.updatedCount).toBe(0)
+  })
+
   it('preserves an explicit null columnMapping (intentional clear ≠ undefined)', async () => {
     const calls = installFetch({ id: 'r1', updatedCount: 1 })
     await handler(

package/__tests__/page-revalidate-node.test.ts

@@ -0,0 +1,276 @@
+import { nodeRegistry } from '../src'
+
+interface RevalidateResult {
+  revalidated?: string[]
+  warning?: string
+  success?: boolean
+  error?: unknown
+}
+
+interface FetchCall {
+  url: string
+  init: {
+    method: string
+    headers: Record<string, string>
+    body: string
+  }
+}
+
+const source = () => nodeRegistry['page-revalidate'].generateHandler()
+
+/**
+ * Runs the emitted handler the way the generated app does: as runtime source in
+ * a scope that provides only `globalThis`, `window` and `fetch`. `process` is
+ * reached through the injected `globalThis`, which is exactly how the handler
+ * has to read it to survive the browser webpack.
+ */
+const runHandler = async (
+  config: Record<string, unknown>,
+  options: {
+    secret?: string
+    context?: Record<string, unknown>
+    // tslint:disable-next-line:no-any
+    respond?: (call: FetchCall) => any
+    calls?: FetchCall[]
+  } = {}
+): Promise<RevalidateResult> => {
+  const env = options.secret === undefined ? {} : { TQ_CACHE_SECRET: options.secret }
+  const calls = options.calls || []
+
+  // tslint:disable-next-line:no-any
+  const fetchImpl = async (url: string, init: any) => {
+    const call: FetchCall = { url, init }
+    calls.push(call)
+    if (!options.respond) {
+      throw new Error('offline')
+    }
+    const payload = options.respond(call)
+    return {
+      ok: payload.ok !== false,
+      json: async () => payload.body,
+    }
+  }
+
+  // tslint:disable-next-line:function-constructor
+  const factory = new Function(
+    'globalThis',
+    'window',
+    'fetch',
+    `${source()}; return page_revalidate;`
+  )
+  const fn = factory({ process: { env } }, undefined, fetchImpl)
+
+  return fn(config, options.context || { __baseUrl: 'https://site.test' })
+}
+
+const expectNotFatal = (result: RevalidateResult) => {
+  // Mirrors `isFatalNodeResult` in the emitted runtime: `success: false`, a
+  // string `error`, or `error: true` HALTS the workflow.
+  expect(result.success).toBeUndefined()
+  expect(typeof result.error).not.toBe('string')
+  expect(result.error).not.toBe(true)
+}
+
+describe('page-revalidate node', () => {
+  it('is registered and runs on the server', () => {
+    expect(nodeRegistry['page-revalidate']).toBeDefined()
+    expect(nodeRegistry['page-revalidate'].nodeType).toBe('page-revalidate')
+    // `res.revalidate` only exists inside a server route, and server-side puts
+    // the rebuild in the same segment as the write it follows.
+    expect(nodeRegistry['page-revalidate'].executionEnv).toBe('server')
+  })
+
+  /**
+   * Handlers ship as runtime source and are re-bundled by webpack, which
+   * rewrites `require(`.
+   */
+  it('never requires a module', () => {
+    expect(source()).not.toMatch(/(?<![\w.])require\s*\(/)
+  })
+
+  describe('path resolution', () => {
+    it('posts the configured paths to the revalidate route', async () => {
+      const calls: FetchCall[] = []
+      const result = await runHandler(
+        { paths: ['/pages/welcome', '/pages/about'] },
+        {
+          secret: 'sekret',
+          calls,
+          respond: () => ({ body: { ok: true, revalidated: ['/pages/welcome'], failed: [] } }),
+        }
+      )
+
+      expect(calls).toHaveLength(1)
+      expect(calls[0].url).toBe('https://site.test/api/tq-revalidate')
+      expect(calls[0].init.method).toBe('POST')
+      expect(calls[0].init.headers['x-tq-cache-secret']).toBe('sekret')
+      expect(JSON.parse(calls[0].init.body)).toEqual({
+        paths: ['/pages/welcome', '/pages/about'],
+      })
+      expect(result.revalidated).toEqual(['/pages/welcome'])
+      expect(result.warning).toBeUndefined()
+    })
+
+    /**
+     * A path built from a database column routinely arrives as the bare slug,
+     * and `res.revalidate` only accepts a site-root-relative path.
+     */
+    it('gives a bare slug a leading slash', async () => {
+      const calls: FetchCall[] = []
+      await runHandler(
+        { paths: ['pages/welcome'] },
+        { secret: 'sekret', calls, respond: () => ({ body: { ok: true } }) }
+      )
+
+      expect(JSON.parse(calls[0].init.body).paths).toEqual(['/pages/welcome'])
+    })
+
+    /**
+     * An update revalidates the slug the row HAD and the slug it now has — and
+     * when the slug did not change, those are the same string. Rebuilding it
+     * twice would double the work for no effect.
+     */
+    it('drops blanks, unresolved refs and duplicates', async () => {
+      const calls: FetchCall[] = []
+      await runHandler(
+        {
+          paths: [
+            '/pages/welcome',
+            '  ',
+            '/pages/welcome',
+            null,
+            { type: 'workflowContext', nodeId: 'n1', path: ['value'] },
+            'pages/welcome',
+          ],
+        },
+        { secret: 'sekret', calls, respond: () => ({ body: { ok: true } }) }
+      )
+
+      expect(JSON.parse(calls[0].init.body).paths).toEqual(['/pages/welcome'])
+    })
+
+    /*
+     * A step that rebuilds several rows at once resolves ONE reference to an
+     * array of slugs — a bulk delete cannot know at build time how many rows the
+     * admin will select, so it cannot configure a path per row.
+     */
+    it('flattens an array of paths resolved from a single reference', async () => {
+      const calls: FetchCall[] = []
+      await runHandler(
+        { paths: [['/pages/welcome', '/pages/pricing'], '/pages/about'] },
+        { secret: 'sekret', calls, respond: () => ({ body: { ok: true } }) }
+      )
+
+      expect(JSON.parse(calls[0].init.body).paths).toEqual([
+        '/pages/welcome',
+        '/pages/pricing',
+        '/pages/about',
+      ])
+    })
+
+    it('accepts a single path configured as a bare string', async () => {
+      const calls: FetchCall[] = []
+      await runHandler(
+        { paths: '/pages/welcome' },
+        { secret: 'sekret', calls, respond: () => ({ body: { ok: true } }) }
+      )
+
+      expect(JSON.parse(calls[0].init.body).paths).toEqual(['/pages/welcome'])
+    })
+
+    it('forwards the internal request headers the deployment protection needs', async () => {
+      const calls: FetchCall[] = []
+      await runHandler(
+        { paths: ['/pages/welcome'] },
+        {
+          secret: 'sekret',
+          calls,
+          context: {
+            __baseUrl: 'https://site.test',
+            __internalHeaders: { cookie: '_vercel_jwt=abc' },
+          },
+          respond: () => ({ body: { ok: true } }),
+        }
+      )
+
+      expect(calls[0].init.headers.cookie).toBe('_vercel_jwt=abc')
+    })
+  })
+
+  /**
+   * THE regression this node is shaped around. The runtime treats
+   * `success: false` / a string `error` as FATAL, so a page that could not be
+   * rebuilt would halt the workflow AFTER the row was already written — no
+   * success toast, no navigation, and an error for an action that worked. Every
+   * failure mode below has to report a warning instead.
+   */
+  describe('never reports failure in a shape the runtime treats as fatal', () => {
+    it('with no paths configured', async () => {
+      const calls: FetchCall[] = []
+      const result = await runHandler({}, { secret: 'sekret', calls })
+
+      expect(result.revalidated).toEqual([])
+      expect(result.warning).toContain('No page paths')
+      expect(calls).toHaveLength(0)
+      expectNotFatal(result)
+    })
+
+    it('with every configured path blank', async () => {
+      const result = await runHandler({ paths: ['', '   '] }, { secret: 'sekret' })
+
+      expect(result.revalidated).toEqual([])
+      expectNotFatal(result)
+    })
+
+    it('with no secret configured', async () => {
+      const calls: FetchCall[] = []
+      const result = await runHandler({ paths: ['/pages/welcome'] }, { calls })
+
+      expect(result.revalidated).toEqual([])
+      expect(result.warning).toContain('TQ_CACHE_SECRET')
+      // Nothing is sent without the credential the route requires.
+      expect(calls).toHaveLength(0)
+      expectNotFatal(result)
+    })
+
+    it('when the route answers with an error status', async () => {
+      const result = await runHandler(
+        { paths: ['/pages/welcome'] },
+        { secret: 'sekret', respond: () => ({ ok: false, body: { error: 'Unauthorized' } }) }
+      )
+
+      expect(result.revalidated).toEqual([])
+      expect(result.warning).toBe('Unauthorized')
+      expectNotFatal(result)
+    })
+
+    it('when the route is unreachable', async () => {
+      const result = await runHandler({ paths: ['/pages/welcome'] }, { secret: 'sekret' })
+
+      expect(result.revalidated).toEqual([])
+      expect(result.warning).toBe('offline')
+      expectNotFatal(result)
+    })
+
+    /**
+     * `res.revalidate` throws for a path that was never statically generated —
+     * the normal case for a page whose row was just deleted. The paths that DID
+     * rebuild are still reported.
+     */
+    it('when some paths could not be rebuilt', async () => {
+      const result = await runHandler(
+        { paths: ['/pages/welcome', '/pages/gone'] },
+        {
+          secret: 'sekret',
+          respond: () => ({
+            body: { ok: true, revalidated: ['/pages/welcome'], failed: ['/pages/gone'] },
+          }),
+        }
+      )
+
+      expect(result.revalidated).toEqual(['/pages/welcome'])
+      expect(result.warning).toContain('/pages/gone')
+      expectNotFatal(result)
+    })
+  })
+})

package/__tests__/payment-refund.test.ts

@@ -0,0 +1,135 @@
+import { loadHandler, HandlerFn } from './_helpers/load-handler'
+import { paymentRefund } from '../src/nodes/payment/payment-refund'
+import { resolveHandlerEntryName } from '../src/nodes/types'
+import { collectSecrets } from '../src/secret-collector'
+
+interface RefundResult {
+  success: boolean
+  refundId: string
+  amount: number
+  currency: string
+  status: string
+  error: string
+}
+
+describe('payment-refund', () => {
+  const handler: HandlerFn = loadHandler('payment-refund')
+  const source = paymentRefund.generateHandler()
+
+  it('is a SERVER node that continues the workflow', () => {
+    expect(paymentRefund.executionEnv).toBe('server')
+    // Unlike a charge, a refund must NOT be terminal: the steps that record it,
+    // restock it and email the buyer all run after it.
+    expect(paymentRefund.isTerminal).toBe(false)
+  })
+
+  it('has its provider credentials collected into the generated env', () => {
+    // Without this the exported project ships with no key for the refund node
+    // and every refund fails at runtime with "not configured".
+    const secrets = collectSecrets({
+      workflows: {
+        wf1: {
+          nodes: [
+            {
+              id: 'node-1',
+              type: 'payment-refund',
+              config: { secretKey: 'sk_test_1', clientId: 'id_1', clientSecret: 'cs_1' },
+            },
+          ],
+        },
+      },
+    } as never)
+    expect(secrets.map((secret) => secret.fieldName).sort()).toEqual([
+      'clientId',
+      'clientSecret',
+      'secretKey',
+    ])
+  })
+
+  it('resolves its own entry point out of the concatenated source', () => {
+    // The entry has to be the FIRST statement-level two-parameter function, or
+    // the generated route calls a helper instead.
+    expect(resolveHandlerEntryName(source, 'payment-refund')).toBe('payment_refund')
+  })
+
+  it('reads process through globalThis, which webpack leaves alone', () => {
+    // A bare `process` is rewritten by the GUI's browser packer into a name
+    // that does not exist on the Vercel Node runtime.
+    expect(source).toContain('globalThis.process.env')
+    // …and nowhere is `process.env` read WITHOUT that prefix.
+    expect(source.replace(/globalThis\.process\.env/g, '')).not.toContain('process.env')
+  })
+
+  it('keeps each currency list in the SAME snapshot as the code that reads it', () => {
+    // A declaration in one `.toString()`'d function and its reference in
+    // another is the "Oo is not defined" bug — a minifier renames the two
+    // independently and the generated file references a name it never declares.
+    // Slicing the emitted source per function is the only way to check that.
+    for (const fnName of ['toProviderMinorUnits', 'fromProviderMinorUnits']) {
+      const start = source.indexOf(`function ${fnName}`)
+      expect(start).toBeGreaterThanOrEqual(0)
+      const next = source.indexOf('\nfunction ', start + 1)
+      const body = next === -1 ? source.slice(start) : source.slice(start, next)
+      expect(body).toContain('zeroDecimalCurrencies = [')
+      expect(body).toContain('threeDecimalCurrencies = [')
+      expect(body).toContain('zeroDecimalCurrencies.indexOf')
+    }
+  })
+
+  it('refuses without a payment reference instead of calling a provider', async () => {
+    const result = (await handler({ currency: 'usd' }, {})) as RefundResult
+    expect(result.success).toBe(false)
+    expect(result.error).toMatch(/no payment reference/i)
+    expect(result.refundId).toBe('')
+  })
+
+  it('reports missing Stripe credentials as an actionable error', async () => {
+    const saved = process.env.STRIPE_SECRET_KEY
+    delete process.env.STRIPE_SECRET_KEY
+    try {
+      const result = (await handler(
+        { providerType: 'stripe', paymentReference: 'pi_1', currency: 'usd' },
+        {}
+      )) as RefundResult
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('STRIPE_SECRET_KEY')
+      // The shape stays constant on every path, so a downstream node can bind
+      // to it without knowing which branch ran.
+      expect(result).toMatchObject({ refundId: '', amount: 0, status: '' })
+    } finally {
+      if (saved !== undefined) {
+        process.env.STRIPE_SECRET_KEY = saved
+      }
+    }
+  })
+
+  it('reports missing PayPal credentials without attempting a network call', async () => {
+    const savedId = process.env.PAYPAL_CLIENT_ID
+    const savedSecret = process.env.PAYPAL_CLIENT_SECRET
+    delete process.env.PAYPAL_CLIENT_ID
+    delete process.env.PAYPAL_CLIENT_SECRET
+    try {
+      const result = (await handler(
+        { providerType: 'paypal', paymentReference: 'cap_1', currency: 'usd' },
+        {}
+      )) as RefundResult
+      expect(result.success).toBe(false)
+      expect(result.error).toMatch(/PayPal credentials are not configured/i)
+    } finally {
+      if (savedId !== undefined) {
+        process.env.PAYPAL_CLIENT_ID = savedId
+      }
+      if (savedSecret !== undefined) {
+        process.env.PAYPAL_CLIENT_SECRET = savedSecret
+      }
+    }
+  })
+
+  it('always returns an answer rather than throwing, so bookkeeping can still run', async () => {
+    // A declined refund is a branch the workflow takes, not a crash that takes
+    // the whole segment — including the steps that record what happened — down.
+    await expect(
+      handler({ providerType: 'stripe', paymentReference: 'pi_1', currency: 'usd' }, {})
+    ).resolves.toBeDefined()
+  })
+})

package/dist/cjs/api-route-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-route-generator.d.ts","sourceRoot":"","sources":["../../src/api-route-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAIZ,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAqBzC,eAAO,MAAM,6BAA6B,YAC/B,eAAe,iBACT,MAAM,eACR,sBAAsB,KAClC,MAsXF,CAAA;AAED,eAAO,MAAM,kBAAkB,YAAa,eAAe,KAAG,OAE7D,CAAA;AAED,eAAO,MAAM,sCAAsC,YACxC,eAAe,iBACT,MAAM,eACR,sBAAsB,KAClC,MA+bF,CAAA;AA0HD,eAAO,MAAM,oBAAoB,aACrB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MAuFF,CAAA;AAED,eAAO,MAAM,mBAAmB,eAClB,MAAM,aACP,MAAM,iBACF,MAAM,KACpB,MAuBF,CAAA;AAED,eAAO,MAAM,oBAAoB,aAAc,YAAY,KAAG,MAa7D,CAAA;AAoRD,eAAO,MAAM,+BAA+B,aAChC,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MA0MF,CAAA;AAED,eAAO,MAAM,uBAAuB,aAAc,YAAY,KAAG,MAiBhE,CAAA;AAED,eAAO,MAAM,mBAAmB,aAAc,YAAY,KAAG,MAAM,EAqBlE,CAAA"}
+{"version":3,"file":"api-route-generator.d.ts","sourceRoot":"","sources":["../../src/api-route-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAIZ,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAqBzC,eAAO,MAAM,6BAA6B,YAC/B,eAAe,iBACT,MAAM,eACR,sBAAsB,KAClC,MAsXF,CAAA;AAED,eAAO,MAAM,kBAAkB,YAAa,eAAe,KAAG,OAE7D,CAAA;AAED,eAAO,MAAM,sCAAsC,YACxC,eAAe,iBACT,MAAM,eACR,sBAAsB,KAClC,MA+bF,CAAA;AA2HD,eAAO,MAAM,oBAAoB,aACrB,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MAuFF,CAAA;AAED,eAAO,MAAM,mBAAmB,eAClB,MAAM,aACP,MAAM,iBACF,MAAM,KACpB,MAuBF,CAAA;AAED,eAAO,MAAM,oBAAoB,aAAc,YAAY,KAAG,MAa7D,CAAA;AAoRD,eAAO,MAAM,+BAA+B,aAChC,YAAY,gBACR,OAAO,MAAM,EAAE,sBAAsB,CAAC,KACnD,MA0MF,CAAA;AAED,eAAO,MAAM,uBAAuB,aAAc,YAAY,KAAG,MAiBhE,CAAA;AAED,eAAO,MAAM,mBAAmB,aAAc,YAAY,KAAG,MAAM,EAqBlE,CAAA"}

package/dist/cjs/api-route-generator.js

@@ -936,6 +936,7 @@ const CLIENT_ONLY_NODES = new Set([
     'browser-text-to-speech',
     'browser-get-media-devices',
     'browser-speech-to-text',
+    'browser-speech-recognition',
     'general-trigger-download',
     'general-extract-form-data',
     'general-emit-custom-event',