@teleporthq/teleport-plugin-next-workflows 0.43.62 → 0.43.64

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/__tests__/state-same-run-write-then-read.test.ts

@@ -0,0 +1,225 @@
+// A workflow that WRITES a state key and then READS it back in the same run
+// used to get the value from before the write.
+//
+// `state-update-local-state` calls the React setter, which only schedules a
+// render, and `state-get-local-state` deliberately reads `stateValuesRef`
+// (the "latest committed" values) rather than the trigger-time snapshot. The
+// ref is rebuilt from state on render, so between the write and the next
+// render it still held the old value.
+//
+// The chat's option chips are exactly this sequence — write the chip's text
+// into the input state, then invoke the node that reads it back — so clicking
+// a chip re-sent the previous message, and the assistant answered the question
+// before the one the visitor had just chosen.
+
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+const extractFunctionSource = (haystack: string, funcDecl: string): string => {
+  const startIdx = haystack.indexOf(funcDecl)
+  if (startIdx === -1) {
+    throw new Error('Helper not found: ' + funcDecl)
+  }
+  let depth = 0
+  let i = haystack.indexOf('{', startIdx)
+  if (i === -1) {
+    throw new Error('No opening brace after ' + funcDecl)
+  }
+  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 for ' + funcDecl)
+}
+
+const buildStructure = (): any => {
+  const workflow = {
+    id: 'wf-1',
+    name: 'Test WF',
+    trigger: {
+      type: 'event-page-loaded',
+      nodeId: 'trigger-1',
+      scope: 'page',
+      config: { pageId: 'page-1' },
+    },
+    nodes: [
+      {
+        id: 'update-1',
+        type: 'state-update-local-state',
+        config: { property: 'chatInputValue', value: 'x' },
+        stepNumber: 1,
+        label: 'X',
+      },
+    ],
+    edges: [{ id: 'e', source: 'trigger-1', target: 'update-1' }],
+  }
+  return {
+    uidl: {
+      name: 'Page',
+      outputOptions: { pageId: 'page-1', fileName: 'page-1' },
+      node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+      stateDefinitions: {
+        chatInputValue: { type: 'string', defaultValue: '' },
+        draft: { 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: {},
+  }
+}
+
+interface Harness {
+  update: (config: Record<string, unknown>, context: unknown) => Promise<unknown>
+  batchUpdate: (config: Record<string, unknown>, context: unknown) => Promise<unknown>
+  read: (config: Record<string, unknown>, context: unknown) => Promise<{ value: unknown }>
+  /** What React has actually committed — only advances on "render". */
+  committed: Record<string, unknown>
+  render: () => void
+}
+
+/**
+ * Instantiates the emitted `__createWorkflowHandlers` against a fake React:
+ * setters record into `pending`, and the ref is only rebuilt from `pending`
+ * when `render()` is called — the timing that made the bug possible.
+ */
+const buildHarness = async (): Promise<Harness> => {
+  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')
+  }
+  const moduleCode = String(moduleChunk.content)
+
+  // The factory returns only its trigger wiring, so capture the handler map
+  // itself at the point it is built.
+  const HANDLERS_DECL = 'const __handlers = Object.assign({}, workflowClientHandlers);'
+  const factorySource = extractFunctionSource(moduleCode, 'function __createWorkflowHandlers')
+  if (!factorySource.includes(HANDLERS_DECL)) {
+    throw new Error('handler map declaration moved; update this test')
+  }
+
+  const source = [
+    extractFunctionSource(moduleCode, 'function __resolveName'),
+    extractFunctionSource(moduleCode, 'function __defaultValueForType'),
+    extractFunctionSource(moduleCode, 'function __coerceValue'),
+    factorySource.replace(HANDLERS_DECL, HANDLERS_DECL + '\n  __captureHandlers(__handlers);'),
+    'return __createWorkflowHandlers;',
+  ].join('\n')
+
+  const stateTypes = { chatInputValue: 'string', draft: 'object' }
+  const committed: Record<string, unknown> = { chatInputValue: '', draft: {} }
+  const pending: Record<string, unknown> = { ...committed }
+  const stateSetters: Record<string, (v: unknown) => void> = {
+    chatInputValue: (v) => {
+      pending.chatInputValue = v
+    },
+    draft: (v) => {
+      pending.draft = v
+    },
+  }
+  // Rebuilt from committed state on every render, exactly like the emitted
+  // `__wfStateRef.current = { ... }` assignment.
+  const stateValuesRef = { current: { ...committed } }
+
+  let handlers: Record<string, (config: any, context: any) => Promise<any>> = {}
+  // `__handlers` starts as a copy of the shared client handlers; the state
+  // handlers under test are assigned over it, so an empty map is enough.
+  const factory = new Function('stateTypes', 'workflowClientHandlers', '__captureHandlers', source)(
+    stateTypes,
+    {},
+    (map: Record<string, any>) => {
+      handlers = map
+    }
+  )
+  factory(stateSetters, stateTypes, stateValuesRef)
+
+  return {
+    update: handlers['state-update-local-state'],
+    batchUpdate: handlers['state-batch-update'],
+    read: handlers['state-get-local-state'],
+    committed,
+    render: () => {
+      Object.assign(committed, pending)
+      stateValuesRef.current = { ...committed }
+    },
+  }
+}
+
+describe('state written and read back inside one workflow run', () => {
+  it('reads the value the run just wrote, before React has re-rendered', async () => {
+    const h = await buildHarness()
+    const context = { __stateValues: { chatInputValue: 'the previous message' } }
+
+    await h.update({ property: 'chatInputValue', value: 'the message just chosen' }, context)
+    const result = await h.read({ property: 'chatInputValue' }, context)
+
+    expect(result.value).toBe('the message just chosen')
+  })
+
+  it('still reads the written value after the render lands', async () => {
+    const h = await buildHarness()
+    const context = { __stateValues: { chatInputValue: '' } }
+
+    await h.update({ property: 'chatInputValue', value: 'chosen' }, context)
+    h.render()
+    const result = await h.read({ property: 'chatInputValue' }, context)
+
+    expect(result.value).toBe('chosen')
+    // The setter really ran; the ref write is an early mirror of it, not a
+    // substitute that would leave React holding something else.
+    expect(h.committed.chatInputValue).toBe('chosen')
+  })
+
+  it('applies to a batch write too', async () => {
+    const h = await buildHarness()
+    const context = { __stateValues: {} }
+
+    await h.batchUpdate({ updates: [{ key: 'chatInputValue', value: 'batched' }] }, context)
+    const result = await h.read({ property: 'chatInputValue' }, context)
+
+    expect(result.value).toBe('batched')
+  })
+
+  it('leaves a key the page does not own to the warning path', async () => {
+    const h = await buildHarness()
+    const warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+    const context = { __stateValues: {} }
+
+    await h.update({ property: 'notOnThisPage', value: 'nope' }, context)
+    const result = await h.read({ property: 'notOnThisPage' }, context)
+
+    // No setter means no state write, so the ref must not claim otherwise.
+    expect(result.value).toBeUndefined()
+    expect(warn).toHaveBeenCalled()
+    warn.mockRestore()
+  })
+})