Hacktoberfest 2026: the issues maintainers tagged for October, open and beginner-friendly. Browse Hacktoberfest issues

2.0.0-rc.14: until() through a synchronous memo misses optimistic confirmation

Open
  • Is something wrong?
#3,943 0 comments 0 reactions 0 assignees View on GitHub

Maintainers usually reply within 1 day

Nobody has claimed this yet.

Assessment

Difficulty
4/5
Estimated time
3-5 days
Newbie friendliness
35/100
Issue type
Bug
Clarity
Clearly specified
Activity status
Active
Tech stack
typescript
Domain
frontend

Research direction

Start by reproducing with the playground component in the issue, then swap the predicate between doubled() and count() to confirm the memo is the difference. The payload names no source files, so you will need to find where until() subscribes and how a synchronous createMemo propagates optimistic values on confirmation. Done when yield until(() => doubled() === 2) completes after setSource(1), matching the direct-read control.

Written by the indexing model from the issue text.

Description

Describe the bug

On 2.0.0-rc.14, an action waiting with until() through a synchronous memo remains pending when the actual source confirms its optimistic prediction. Reading the optimistic accessor directly in the predicate completes the same action.

The predicate subscribes before confirmation arrives. The prediction alone correctly does not satisfy the wait, but confirming it does not resolve the wait through the memo either.

Your Example Website or App

https://s.olid.uk/?id=d1d1a3ee-70c8-4afe-966d-258809cb4f06

The playground uses published 2.0.0-rc.14. Here is the full component, including the actual source update in the Confirm button:

import { action, createMemo, createOptimistic, createSignal, until } from "solid-js";
import { render } from "solid-js/web";

function App() {
  const [source, setSource] = createSignal(0);
  const [count, guess] = createOptimistic(() => source());
  const doubled = createMemo(() => count() * 2);
  const [completed, setCompleted] = createSignal(false);

  const save = action(function* () {
    guess(1);
    yield Promise.resolve();
    // Direct-read control: yield until(() => count() === 1);
    yield until(() => doubled() === 2);
  });

  return (
    <main>
      <button onClick={() => save().then(() => setCompleted(true))}>1. Start</button>
      <button onClick={() => setSource(1)}>2. Confirm</button>
      <p>Displayed count: {count()}</p>
      <p>Doubled memo: {doubled()}</p>
      <p>Action completed: {String(completed())}</p>
    </main>
  );
}

render(() => <App />, document.getElementById("app")!);
Steps to Reproduce the Bug or Issue
  1. Open the playground and click 1. Start.
  2. The displayed count becomes 1 and the doubled memo becomes 2. Action completion remains false, as expected while the prediction is unconfirmed.
  3. Click 2. Confirm to set the actual source to 1.
  4. Action completion still remains false.
  5. Change the wait to yield until(() => count() === 1), rebuild, and repeat. Action completion becomes true after confirmation.

Both the failing memo case and the successful direct-read control were verified in the browser.

Expected behavior

The optimistic prediction alone should not satisfy until(). Once the actual source confirms the prediction, the predicate through the synchronous memo should resolve and the action should complete, just as the direct-read predicate does.

Platform
  • OS: Linux (WSL)
  • Browser: Chrome for Testing 153.0.8010.12, tested with Playwright
  • Solid: 2.0.0-rc.14
Dominant language
TypeScript
Stars
36.1k
Forks
1.1k
Avg merge
11h 34m
Merged PRs (30d)
341

Getting set up

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from solidjs/solid

All issues in solidjs/solid

Similar issues

More TypeScript issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.