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

package/__tests__/ai-chat-tool-dispatch-segments.test.ts

@@ -0,0 +1,110 @@
+import { splitIntoSegments } from '../src/segment-splitter'
+import type { UIDLWorkflow, UIDLWorkflowNode, UIDLWorkflowEdge } from '@teleporthq/teleport-types'
+
+/**
+ * The AI Assistant Chat's action layer stands or falls on ONE property of the
+ * generated app: the tool must run BEFORE the answer is written, so the reply
+ * can report truthfully what happened.
+ *
+ * The tool runs inside a `general-custom-node`, which the splitter pins to the
+ * CLIENT, while both AI calls are SERVER nodes. So the walk has to produce
+ * `[server: decide] [client: run] [server: answer]`.
+ *
+ * The chat used to express this with two plain edges out of a parse node — one
+ * into the tool chain, one into the answer — and relied on the answer's PROMPT
+ * referencing the tool's summary to force the ordering, because
+ * `getTopologicalOrder` turns a `workflowContext` reference into a dependency
+ * edge. That worked, but only by accident of the data flow: remove the
+ * reference and the answer was written before the tool ran.
+ *
+ * The dispatch now lives inside its own custom node, so the ordering comes from
+ * a real EDGE. This test pins both halves: the three-segment shape, and that it
+ * survives even with no prompt reference at all.
+ */
+
+const ctx = (nodeId: string, path: string[]) => ({ type: 'workflowContext', nodeId, path })
+
+const node = (
+  id: string,
+  type: string,
+  stepNumber: number,
+  config: Record<string, unknown> = {}
+): UIDLWorkflowNode => ({ id, type, label: id, config, stepNumber } as unknown as UIDLWorkflowNode)
+
+const edge = (source: string, target: string, sourceHandle?: string): UIDLWorkflowEdge =>
+  ({ id: `${source}->${target}`, source, target, sourceHandle } as unknown as UIDLWorkflowEdge)
+
+/** The chat's shape from the merge script onward. */
+function buildChatWorkflow(options: { answerReferencesOutcome: boolean }): UIDLWorkflow {
+  const nodes: UIDLWorkflowNode[] = [
+    node('merge', 'general-custom-js', 1, { context: 'server', code: 'x' }),
+    node('decide', 'ai-custom-prompt', 2, {
+      jsonMode: true,
+      prompt: ['ctx:', ctx('merge', ['merge', 'context'])],
+    }),
+    node('run', 'general-custom-node', 3, {
+      customNodeId: 'custom_run_action',
+      parameters: [{ key: 'decisionText', value: ctx('decide', ['decide', 'response']) }],
+    }),
+    node('answer', 'ai-custom-prompt', 4, {
+      streaming: true,
+      prompt: [
+        'Context:',
+        ctx('merge', ['merge', 'context']),
+        ...(options.answerReferencesOutcome
+          ? ['\nOutcome: ', ctx('run', ['run', 'outcomeText'])]
+          : []),
+      ],
+    }),
+  ]
+
+  const edges: UIDLWorkflowEdge[] = [
+    edge('merge', 'decide'),
+    edge('decide', 'run'),
+    edge('run', 'answer'),
+  ]
+
+  return { name: 'send-chat-message', nodes, edges, trigger: { type: 'manual' } } as UIDLWorkflow
+}
+
+const segmentOf = (segments: ReturnType<typeof splitIntoSegments>, nodeId: string): number =>
+  segments.findIndex((segment) => segment.nodes.some((entry) => entry.id === nodeId))
+
+describe('AI chat tool dispatch — segment ordering', () => {
+  const segments = splitIntoSegments(buildChatWorkflow({ answerReferencesOutcome: true }))
+
+  it('runs the action on the CLIENT, where general-custom-node is dispatched', () => {
+    // The server handler for general-custom-node is a stub: placed in a server
+    // segment the nested custom node never runs and downstream references
+    // resolve to the raw marker object.
+    expect(segments[segmentOf(segments, 'run')].env).toBe('client')
+  })
+
+  it('keeps both AI calls on the server', () => {
+    expect(segments[segmentOf(segments, 'decide')].env).toBe('server')
+    expect(segments[segmentOf(segments, 'answer')].env).toBe('server')
+  })
+
+  it('orders the answer AFTER the action', () => {
+    const answerSegment = segmentOf(segments, 'answer')
+    expect(answerSegment).toBeGreaterThan(segmentOf(segments, 'decide'))
+    expect(answerSegment).toBeGreaterThan(segmentOf(segments, 'run'))
+  })
+
+  it('produces exactly the three-segment shape the design depends on', () => {
+    expect(segments.map((segment) => segment.env)).toEqual(['server', 'client', 'server'])
+  })
+
+  it('holds the ordering on the EDGE, not on the prompt reference', () => {
+    // The regression this replaces: with the old two-edges-out-of-parse shape,
+    // dropping the prompt reference let the answer overtake the tool. A real
+    // edge cannot be overtaken, so the shape is identical either way.
+    const withoutReference = splitIntoSegments(
+      buildChatWorkflow({ answerReferencesOutcome: false })
+    )
+    expect(withoutReference.map((segment) => segment.env)).toEqual(['server', 'client', 'server'])
+    expect(segmentOf(withoutReference, 'answer')).toBeGreaterThan(
+      segmentOf(withoutReference, 'run')
+    )
+  })
+})

package/__tests__/ai-custom-prompt-json-mode.test.ts

@@ -0,0 +1,78 @@
+import { aiCustomPrompt } from '../src/nodes/ai/ai-custom-prompt'
+
+/**
+ * `ai-custom-prompt` used to hard-code `jsonMode: false`, so a node whose only
+ * job is to emit a machine-readable decision (the AI Assistant Chat's tool
+ * router) had no way to ask the provider for a JSON-only reply. The flag is now
+ * forwarded from the node config.
+ *
+ * The generated provider utils are emitted as
+ * `var __ai_callProvider = typeof __ai_callProvider !== 'undefined' ? … : <def>`,
+ * so defining the name ahead of the handler source substitutes a spy for the
+ * real provider call.
+ */
+type ProviderCall = { jsonMode?: boolean; systemMessage?: string; userMessage?: string }
+type PromptHandler = (
+  config: Record<string, unknown>,
+  context: Record<string, unknown>,
+  streamCallback?: unknown
+) => Promise<Record<string, unknown>>
+
+function loadHandlerWithProviderSpy(): { handler: PromptHandler; calls: ProviderCall[] } {
+  const calls: ProviderCall[] = []
+  const source = aiCustomPrompt.generateHandler()
+  // eslint-disable-next-line no-new-func
+  const factory = new Function(
+    '__calls',
+    [
+      'var __ai_callProvider = function (params) {',
+      '  __calls.push(params);',
+      '  return Promise.resolve({ content: \'{"action":"none"}\', usage: { total_tokens: 3 } });',
+      '};',
+      source,
+      'return ai_custom_prompt;',
+    ].join('\n')
+  )
+  return { handler: factory(calls) as PromptHandler, calls }
+}
+
+describe('ai-custom-prompt jsonMode passthrough', () => {
+  it('asks the provider for JSON when the node config sets jsonMode', async () => {
+    const { handler, calls } = loadHandlerWithProviderSpy()
+
+    const result = await handler({ prompt: 'Decide.', token: 'sk-test', jsonMode: true }, {})
+
+    expect(calls).toHaveLength(1)
+    expect(calls[0].jsonMode).toBe(true)
+    expect(result.response).toBe('{"action":"none"}')
+  })
+
+  it('leaves JSON mode off for an ordinary prompt node', async () => {
+    const { handler, calls } = loadHandlerWithProviderSpy()
+
+    await handler({ prompt: 'Write a haiku.', token: 'sk-test' }, {})
+
+    expect(calls[0].jsonMode).toBe(false)
+  })
+
+  it('treats any non-true value as off, so a stale string config cannot enable it', async () => {
+    const { handler, calls } = loadHandlerWithProviderSpy()
+
+    await handler({ prompt: 'Hi.', token: 'sk-test', jsonMode: 'true' }, {})
+
+    expect(calls[0].jsonMode).toBe(false)
+  })
+
+  it('never sends jsonMode down the streaming path', async () => {
+    const { handler, calls } = loadHandlerWithProviderSpy()
+    const chunks: string[] = []
+
+    // No stream callback => the streaming branch is skipped; with one, the
+    // handler must not reach __ai_callProvider at all.
+    await handler({ prompt: 'Hi.', token: 'sk-test', jsonMode: true, streaming: true }, {}, () =>
+      chunks.push('x')
+    )
+
+    expect(calls).toHaveLength(0)
+  })
+})

package/__tests__/cart-get-total-storefront-tax.test.ts

@@ -158,8 +158,13 @@ describe('cart-get-total — storefront tax', () => {
       tax: 0,
       total: 0,
       itemCount: 0,
+      // No readable cart means no per-product markdown to record on the order.
+      productDiscountTotal: 0,
       deliveryConfig: null,
       taxConfig: { storefrontTaxRate: 0 },
+      // Unreadable storage means no applied voucher, which the place-order
+      // workflow must see as "nothing to re-validate" rather than as absent.
+      voucher: null,
     })
   })
 })

package/__tests__/controlled-select-plugin.test.ts

@@ -0,0 +1,170 @@
+import { parse } from '@babel/parser'
+import generate from '@babel/generator'
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+/**
+ * The unit tests in `controlled-select.ts` pin the rule; these run the real
+ * plugin, because the defect was never in the rule — it was in WHERE the
+ * decision got made.
+ *
+ * `makeControlUncontrolledWhenNoChangeHandler` demotes `value` → `defaultValue`
+ * on a form control with no change handler, while the JSX is generated. Element
+ * triggers are attached afterwards, by this plugin. So a `<select>` whose only
+ * handler is a workflow was always demoted, and `defaultValue` is read once at
+ * mount — state established after hydration (a `?sortBy=` deep link) never
+ * reached the DOM. The products list shipped sorted correctly under a dropdown
+ * reading "Name (A-Z)".
+ */
+
+const changeWorkflow = (elementHtmlId: string, property: string) => ({
+  id: `wf-${property}`,
+  name: 'Sort changed',
+  trigger: {
+    type: 'event-element-event',
+    nodeId: 'trigger-change',
+    scope: 'element',
+    config: { elementHtmlId, eventType: 'change' },
+  },
+  nodes: [
+    {
+      id: 'update-1',
+      type: 'state-update-local-state',
+      config: {
+        property,
+        value: {
+          type: 'workflowContext',
+          nodeId: 'trigger-change',
+          path: ['trigger-change', 'value'],
+        },
+      },
+      stepNumber: 1,
+    },
+  ],
+  edges: [{ id: 'e1', source: 'trigger-change', target: 'update-1' }],
+})
+
+const runPlugin = async (
+  componentSource: string,
+  workflows: Record<string, unknown>
+): Promise<string> => {
+  const ast = parse(componentSource, { plugins: ['jsx'] })
+  const chunk = {
+    type: 'chunk-type-ast',
+    name: 'jsx-component',
+    content: ast.program.body[0],
+  }
+  const structure: any = {
+    uidl: {
+      name: 'ProductsList',
+      outputOptions: { pageId: 'page-products', fileName: 'products' },
+      stateDefinitions: {},
+      node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+    },
+    chunks: [chunk],
+    options: { workflows: { workflows, customNodes: {} } },
+    dependencies: {},
+  }
+  await createNextWorkflowPlugin({ isPage: true })(structure)
+  return generate(chunk.content as any).code
+}
+
+const SORT_SELECT = (extraAttrs = '') => `const ProductsList = (props) => {
+  return (
+    <select id="thq_sort" ${extraAttrs} defaultValue={sortBy}>
+      <option value="name-asc">Name (A-Z)</option>
+      <option value="price-asc">Price (low to high)</option>
+    </select>
+  )
+}`
+
+describe('a select made controlled by its workflow', () => {
+  it('ships `value=`, not `defaultValue=`', async () => {
+    const code = await runPlugin(SORT_SELECT(), {
+      'wf-sortBy': changeWorkflow('thq_sort', 'sortBy'),
+    })
+    expect(code).toContain('value={sortBy}')
+    expect(code).not.toContain('defaultValue={sortBy}')
+    expect(code).toContain(`__wfRef.current.elementTriggers["thq_sort"]["onChange"]`)
+  })
+
+  it('keeps the options and the rest of the element intact', async () => {
+    const code = await runPlugin(SORT_SELECT(), {
+      'wf-sortBy': changeWorkflow('thq_sort', 'sortBy'),
+    })
+    expect(code).toContain('<option value="name-asc">')
+    expect(code).toContain('<option value="price-asc">')
+    expect(code).toContain('id="thq_sort"')
+  })
+
+  it('does not end up with both props when the JSX was already controlled', async () => {
+    const code = await runPlugin(
+      `const ProductsList = (props) => {
+        return <select id="thq_sort" value={sortBy} defaultValue={sortBy} />
+      }`,
+      { 'wf-sortBy': changeWorkflow('thq_sort', 'sortBy') }
+    )
+    expect(code).toContain('value={sortBy}')
+    expect(code).not.toContain('defaultValue')
+  })
+})
+
+describe('what the plugin still leaves uncontrolled', () => {
+  it('a select whose workflow writes some OTHER state', async () => {
+    // Controlling it would freeze the dropdown — nothing moves `sortBy`, so
+    // every selection would snap straight back.
+    const code = await runPlugin(SORT_SELECT(), {
+      'wf-other': changeWorkflow('thq_sort', 'somethingElse'),
+    })
+    expect(code).toContain('defaultValue={sortBy}')
+    expect(code).not.toContain('value={sortBy}')
+  })
+
+  it('a select bound to an entity field rather than a state name', async () => {
+    const code = await runPlugin(
+      `const EditForm = (props) => {
+        return <select id="thq_sort" defaultValue={props.item?.category} />
+      }`,
+      { 'wf-category': changeWorkflow('thq_sort', 'category') }
+    )
+    expect(code).toContain('defaultValue={props.item?.category}')
+  })
+
+  it('a text input, even when its workflow writes the bound state', async () => {
+    // An input needs a SYNCHRONOUS write-back per keystroke; a workflow is an
+    // async pipeline, and a controlled input whose state lags drops characters
+    // and jumps the caret.
+    const code = await runPlugin(
+      `const Chat = (props) => {
+        return <input type="text" id="thq_msg" defaultValue={chatInputValue} />
+      }`,
+      { 'wf-chat': changeWorkflow('thq_msg', 'chatInputValue') }
+    )
+    expect(code).toContain('defaultValue={chatInputValue}')
+    expect(code).not.toContain('value={chatInputValue}')
+  })
+
+  it('a checkbox — a toggle that bounces back reads as broken', async () => {
+    const code = await runPlugin(
+      `const Form = (props) => {
+        return <input type="checkbox" id="thq_agree" defaultChecked={agreed} />
+      }`,
+      { 'wf-agree': changeWorkflow('thq_agree', 'agreed') }
+    )
+    expect(code).toContain('defaultChecked={agreed}')
+    expect(code).not.toContain('checked={agreed}')
+  })
+
+  it('a select whose workflow is triggered by a CLICK, not a change', async () => {
+    const clickWorkflow = {
+      ...changeWorkflow('thq_sort', 'sortBy'),
+      trigger: {
+        type: 'event-element-clicked',
+        nodeId: 'trigger-click',
+        scope: 'element',
+        config: { elementHtmlId: 'thq_sort', eventType: 'click' },
+      },
+    }
+    const code = await runPlugin(SORT_SELECT(), { 'wf-click': clickWorkflow })
+    expect(code).toContain('defaultValue={sortBy}')
+  })
+})

package/__tests__/controlled-select.ts

@@ -0,0 +1,215 @@
+import { parse } from '@babel/parser'
+import * as types from '@babel/types'
+import { UIDLWorkflow } from '@teleporthq/teleport-types'
+import {
+  collectWrittenStateProperties,
+  readBoundStateName,
+  restoreControlledSelectValue,
+} from '../src/controlled-select'
+
+/**
+ * A `<select>` whose only change handler comes from a workflow was shipping as
+ * UNCONTROLLED (`defaultValue`), because the pass that demotes handler-less form
+ * controls runs while the JSX is generated and workflow triggers are attached
+ * afterwards. `defaultValue` is read once at mount, so state established after
+ * hydration never reached the DOM: `/products?sortBy=price-asc` sorted the
+ * products correctly under a dropdown still reading "Name (A-Z)".
+ *
+ * The restore is deliberately narrow, and most of what follows pins what it
+ * refuses to touch — a control made controlled without its handler writing the
+ * bound state is FROZEN, which is a worse defect than the stale label.
+ */
+
+const openingElementOf = (source: string): types.JSXOpeningElement => {
+  const file = parse(`const x = ${source}`, { sourceType: 'module', plugins: ['jsx'] })
+  let found: types.JSXOpeningElement | null = null
+  const walk = (node: unknown): void => {
+    if (!node || typeof node !== 'object') return
+    if ((node as types.Node).type === 'JSXOpeningElement' && !found) {
+      found = node as types.JSXOpeningElement
+      return
+    }
+    for (const value of Object.values(node as Record<string, unknown>)) {
+      if (Array.isArray(value)) value.forEach(walk)
+      else if (value && typeof value === 'object') walk(value)
+    }
+  }
+  walk(file.program)
+  if (!found) throw new Error('no JSX opening element in: ' + source)
+  return found
+}
+
+const attrNames = (element: types.JSXOpeningElement): string[] =>
+  element.attributes
+    .filter((attr): attr is types.JSXAttribute => types.isJSXAttribute(attr))
+    .map((attr) => (types.isJSXIdentifier(attr.name) ? attr.name.name : ''))
+
+const workflowWriting = (...properties: string[]): UIDLWorkflow =>
+  ({
+    id: 'wf',
+    name: 'Sort changed',
+    trigger: { type: 'event-element-event', config: {} },
+    nodes: properties.map((property, index) => ({
+      id: `n${index}`,
+      type: 'state-update-local-state',
+      config: { property },
+    })),
+    edges: [],
+    usedInNodes: {},
+  } as unknown as UIDLWorkflow)
+
+const SORT_SELECT = `<select defaultValue={sortBy} onChange={__wfRef.current.elementTriggers['a']['onChange']} />`
+
+describe('collectWrittenStateProperties', () => {
+  it('reads a local and a global state write', () => {
+    const workflow = {
+      nodes: [
+        { id: '1', type: 'state-update-local-state', config: { property: 'sortBy' } },
+        { id: '2', type: 'state-update-global-state', config: { property: 'cartCount' } },
+      ],
+    } as unknown as UIDLWorkflow
+    expect(collectWrittenStateProperties(workflow)).toEqual(new Set(['sortBy', 'cartCount']))
+  })
+
+  it('reads a batch update, whose targets live under `updates[].key`', () => {
+    const workflow = {
+      nodes: [
+        {
+          id: '1',
+          type: 'state-batch-update',
+          config: { updates: [{ key: 'sortBy' }, { key: 'page' }] },
+        },
+      ],
+    } as unknown as UIDLWorkflow
+    expect(collectWrittenStateProperties(workflow)).toEqual(new Set(['sortBy', 'page']))
+  })
+
+  it('ignores nodes that do not write state, and survives a malformed graph', () => {
+    expect(
+      collectWrittenStateProperties({
+        nodes: [
+          { id: '1', type: 'general-if-statement', config: { property: 'sortBy' } },
+          { id: '2', type: 'state-update-local-state', config: {} },
+          null,
+        ],
+      } as unknown as UIDLWorkflow)
+    ).toEqual(new Set())
+    expect(collectWrittenStateProperties({} as UIDLWorkflow)).toEqual(new Set())
+  })
+})
+
+describe('readBoundStateName', () => {
+  it('reads a bare identifier', () => {
+    const element = openingElementOf('<select defaultValue={sortBy} />')
+    expect(readBoundStateName(element.attributes[0] as types.JSXAttribute)).toBe('sortBy')
+  })
+
+  it('refuses a member expression — an entity field has no state behind it', () => {
+    const element = openingElementOf('<select defaultValue={props.item?.category} />')
+    expect(readBoundStateName(element.attributes[0] as types.JSXAttribute)).toBeNull()
+  })
+
+  it('refuses a string literal', () => {
+    const element = openingElementOf('<select defaultValue="name-asc" />')
+    expect(readBoundStateName(element.attributes[0] as types.JSXAttribute)).toBeNull()
+  })
+})
+
+describe('restoreControlledSelectValue', () => {
+  it('controls a select whose workflow writes the state it is bound to', () => {
+    const element = openingElementOf(SORT_SELECT)
+    restoreControlledSelectValue(element, [workflowWriting('sortBy')])
+    expect(attrNames(element)).toEqual(['value', 'onChange'])
+  })
+
+  it('keeps the binding expression untouched when it renames the prop', () => {
+    const element = openingElementOf(SORT_SELECT)
+    restoreControlledSelectValue(element, [workflowWriting('sortBy')])
+    const value = element.attributes[0] as types.JSXAttribute
+    expect(types.isJSXExpressionContainer(value.value)).toBe(true)
+    expect(readBoundStateName(value)).toBe('sortBy')
+  })
+
+  it('is idempotent', () => {
+    const element = openingElementOf(SORT_SELECT)
+    restoreControlledSelectValue(element, [workflowWriting('sortBy')])
+    restoreControlledSelectValue(element, [workflowWriting('sortBy')])
+    expect(attrNames(element)).toEqual(['value', 'onChange'])
+  })
+
+  it('matches across several workflows on the same onChange', () => {
+    const element = openingElementOf(SORT_SELECT)
+    restoreControlledSelectValue(element, [workflowWriting('unrelated'), workflowWriting('sortBy')])
+    expect(attrNames(element)).toContain('value')
+  })
+})
+
+describe('restoreControlledSelectValue — what it refuses to touch', () => {
+  it('leaves a text input uncontrolled even when its workflow writes the state', () => {
+    // An input accumulates one keystroke at a time and needs a SYNCHRONOUS
+    // write-back per keystroke; a workflow is async, and a controlled input
+    // whose state lags drops characters and jumps the caret.
+    const element = openingElementOf(
+      `<input type="text" defaultValue={chatInputValue} onChange={h} />`
+    )
+    restoreControlledSelectValue(element, [workflowWriting('chatInputValue')])
+    expect(attrNames(element)).toContain('defaultValue')
+    expect(attrNames(element)).not.toContain('value')
+  })
+
+  it('leaves a textarea uncontrolled', () => {
+    const element = openingElementOf(`<textarea defaultValue={draft} onChange={h} />`)
+    restoreControlledSelectValue(element, [workflowWriting('draft')])
+    expect(attrNames(element)).toContain('defaultValue')
+  })
+
+  it('leaves a checkbox alone — a toggle that bounces back reads as broken', () => {
+    const element = openingElementOf(
+      `<input type="checkbox" defaultChecked={agreed} onChange={h} />`
+    )
+    restoreControlledSelectValue(element, [workflowWriting('agreed')])
+    expect(attrNames(element)).toEqual(['type', 'defaultChecked', 'onChange'])
+  })
+
+  it('leaves a select whose workflow writes some OTHER state uncontrolled', () => {
+    // Controlling it would freeze the dropdown: nothing would ever move the
+    // bound state, so every selection would snap back.
+    const element = openingElementOf(SORT_SELECT)
+    restoreControlledSelectValue(element, [workflowWriting('somethingElse')])
+    expect(attrNames(element)).toEqual(['defaultValue', 'onChange'])
+  })
+
+  it('leaves a select bound to an entity field uncontrolled', () => {
+    const element = openingElementOf(`<select defaultValue={props.item?.category} onChange={h} />`)
+    restoreControlledSelectValue(element, [workflowWriting('category')])
+    expect(attrNames(element)).toEqual(['defaultValue', 'onChange'])
+  })
+
+  it('leaves a select with no change handler uncontrolled', () => {
+    // This is the case the demotion exists for: React freezes a controlled
+    // control that has no way to change.
+    const element = openingElementOf(`<select defaultValue={sortBy} />`)
+    restoreControlledSelectValue(element, [workflowWriting('sortBy')])
+    expect(attrNames(element)).toEqual(['defaultValue'])
+  })
+
+  it('leaves a select with no workflows on its onChange uncontrolled', () => {
+    const element = openingElementOf(SORT_SELECT)
+    restoreControlledSelectValue(element, [])
+    expect(attrNames(element)).toEqual(['defaultValue', 'onChange'])
+  })
+
+  it('leaves a capitalised <Select> component alone', () => {
+    const element = openingElementOf(`<Select defaultValue={sortBy} onChange={h} />`)
+    restoreControlledSelectValue(element, [workflowWriting('sortBy')])
+    expect(attrNames(element)).toEqual(['defaultValue', 'onChange'])
+  })
+
+  it('drops a stale defaultValue rather than shipping both props', () => {
+    // React warns about a control carrying `value` and `defaultValue` together
+    // and resolves it unpredictably.
+    const element = openingElementOf(`<select value={sortBy} defaultValue={sortBy} onChange={h} />`)
+    restoreControlledSelectValue(element, [workflowWriting('sortBy')])
+    expect(attrNames(element)).toEqual(['value', 'onChange'])
+  })
+})

package/dist/cjs/controlled-select.d.ts

@@ -0,0 +1,23 @@
+import * as types from '@babel/types';
+import { UIDLWorkflow } from '@teleporthq/teleport-types';
+/** Every state property a workflow's graph writes. */
+export declare const collectWrittenStateProperties: (workflow: UIDLWorkflow) => Set<string>;
+/**
+ * The state name a `defaultValue` binding reads, or `null` when it is not a
+ * plain state reference.
+ *
+ * Only a bare identifier counts. `defaultValue={props.item?.category}` is an
+ * entity column with no state mirror — the very case the demotion exists for —
+ * and a member expression can never be matched against a state-update target
+ * with any confidence.
+ */
+export declare const readBoundStateName: (attr: types.JSXAttribute) => string | null;
+/**
+ * Turns `defaultValue` back into `value` on a `<select>` that a workflow makes
+ * genuinely controlled. Mutates the opening element in place; idempotent, and a
+ * no-op for every element that does not meet BOTH conditions above.
+ *
+ * @param workflows The workflows wired to this element's `onChange`.
+ */
+export declare const restoreControlledSelectValue: (openingElement: types.JSXOpeningElement, workflows: UIDLWorkflow[]) => void;
+//# sourceMappingURL=controlled-select.d.ts.map

package/dist/cjs/controlled-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controlled-select.d.ts","sourceRoot":"","sources":["../../src/controlled-select.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,YAAY,EAAoB,MAAM,4BAA4B,CAAA;AA4E3E,sDAAsD;AACtD,eAAO,MAAM,6BAA6B,aAAc,YAAY,KAAG,IAAI,MAAM,CA0BhF,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,SAAU,MAAM,YAAY,KAAG,MAAM,GAAG,IAMtE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,mBACvB,MAAM,iBAAiB,aAC5B,YAAY,EAAE,KACxB,IAiCF,CAAA"}