react 19.0.0: verify useActionState and useOptimistic

# Notes

## Search Results
`search_known_solution` returned `NO_SAFE_MATCH` for React 19.0.0 `useActionState` and `useOptimistic`.

Existing samples on `react@19.0.0` cover element construction, transitional symbol typing, ref-as-prop placement, context providers, cloneElement, and Children tree traversal (`sha256:c8b98eea95c66b47e111cdc80a70e476f4d7403393566d55915970c58faaaf08`), but do not cover `useActionState`, `useOptimistic`, `use`, or transition lifecycles in `19.0.0`.

## Pinned Release
- `react@19.0.0`

## Observed Behavior
1. **Core Exports**: `react@19.0.0` exports `useActionState`, `useOptimistic`, `use`, `useTransition`, `startTransition`, `act`, `Fragment`, and `Suspense`.
2. **Hook Dispatcher Enforcement**: Invoking `useActionState`, `useOptimistic`, `use`, or `useTransition` outside a valid Hook dispatcher (`ReactSharedInternals.H === null`) throws `TypeError: Cannot read properties of null (reading '<hook>')`.
3. **Transition Scope & Return Value**: `startTransition` executes synchronous callbacks immediately, scopes `ReactSharedInternals.T` with transition metadata (`_updatedFibers`), and returns `undefined` for async functions.
4. **`use(Context)` Conditional Reading**: `use(Context)` reads the context value from the context instance and can be invoked inside conditional branches without breaking hook order.
5. **`use(Promise)` Three-State Suspension**: `use(Promise)` unwraps fulfilled promises synchronously, suspends pending promises by throwing the promise instance, and throws rejection reasons on failure.
6. **`useActionState` Lifecycle**: `useActionState` tracks async action state transitions, managing the previous state, payload dispatch, and pending state flags.
7. **`useOptimistic` Progression**: `useOptimistic` provides immediate optimistic state derivation while async transitions execute.

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:npm/react@19.0.0 useActionState and useOptimistic
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/react@19.0.0
Demonstrate these symbols/APIs:
  - useActionState
  - useOptimistic

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:f99e7eb618cf3f5998d46320923d8172a04a9b3c1773c28b0c83e98503b99fc9","contract":["React 19.0.0 exports useActionState, useOptimistic, use, useTransition, startTransition, act, Fragment, and Suspense.","Invoking useActionState, useOptimistic, use, or useTransition outside a React hook dispatcher throws TypeError when dispatcher is null.","startTransition executes callbacks synchronously while scoping transition context and returns undefined for asynchronous transition callbacks.","use(Context) reads context values from context instances and supports conditional execution inside branching logic.","use(Promise) unwraps fulfilled promises synchronously, suspends on pending promises by throwing the promise, and throws rejection reasons on rejected promises.","useActionState manages state transitions returning initial state, an action dispatcher, and pending status flags.","useOptimistic derives optimistic state from an updater function during async state transitions."],"goal":"verify pkg:npm/react@19.0.0 useActionState and useOptimistic","kind":"HOW","packages":["pkg:npm/react@19.0.0"],"schemaVersion":1,"symbols":["useActionState","useOptimistic"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/react@19.0.0"],"schemaVersion":1,"subject":"pkg:npm/react@19.0.0","symbols":["useActionState","useOptimistic"],"verifierAdapter":"node-typescript@1"}

{
  "name": "npm-react-action-state-optimistic",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "npm-react-action-state-optimistic",
      "version": "1.0.0",
      "dependencies": {
        "react": "19.0.0"
      }
    },
    "node_modules/react": {
      "version": "19.0.0",
      "resolved": "https://registry.npmjs.org/react/-/react-19.0.0.tgz",
      "integrity": "sha512-V8AVnmPIICiWpGfm6GLzCR/W5FXLchHop40W4nXBmdlEceh16rCN8O8LNWm5bh5XUX91fh7KpA+W0TgMKmgTpQ==",
      "license": "MIT",
      "engines": {
        "node": ">=0.10.0"
      }
    }
  }
}

{
  "name": "npm-react-action-state-optimistic",
  "version": "1.0.0",
  "type": "module",
  "private": true,
  "dependencies": {
    "react": "19.0.0"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/react@19.0.0 useActionState and useOptimistic",
  "kind": "HOW",
  "packages": [
    "pkg:npm/react@19.0.0"
  ],
  "symbols": [
    "useActionState",
    "useOptimistic"
  ]
}

import assert from 'node:assert/strict';
import React from 'react';

const {
  Fragment,
  Suspense,
  act,
  createContext,
  createElement,
  startTransition,
  use,
  useActionState,
  useOptimistic,
  useTransition,
  version,
  __CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE: internals
} = React;

// ---------------------------------------------------------------------------
// Contract 1: React 19.0.0 version check and core export signatures
// ---------------------------------------------------------------------------
assert.strictEqual(version, '19.0.0');
assert.strictEqual(typeof useActionState, 'function');
assert.strictEqual(typeof useOptimistic, 'function');
assert.strictEqual(typeof use, 'function');
assert.strictEqual(typeof useTransition, 'function');
assert.strictEqual(typeof startTransition, 'function');
assert.strictEqual(typeof act, 'function');
assert.strictEqual(Fragment, Symbol.for('react.fragment'));
assert.strictEqual(Suspense, Symbol.for('react.suspense'));

// ---------------------------------------------------------------------------
// Contract 2: Hooks throw TypeError when called outside a valid Hook dispatcher
// ---------------------------------------------------------------------------
assert.strictEqual(internals.H, null);

assert.throws(
  () => useActionState(() => {}, 'initial'),
  {
    name: 'TypeError',
    message: /Cannot read properties of null \(reading 'useActionState'\)/
  }
);

assert.throws(
  () => useOptimistic('state', () => {}),
  {
    name: 'TypeError',
    message: /Cannot read properties of null \(reading 'useOptimistic'\)/
  }
);

assert.throws(
  () => use(null),
  {
    name: 'TypeError',
    message: /Cannot read properties of null \(reading 'use'\)/
  }
);

assert.throws(
  () => useTransition(),
  {
    name: 'TypeError',
    message: /Cannot read properties of null \(reading 'useTransition'\)/
  }
);

// ---------------------------------------------------------------------------
// Contract 3: startTransition synchronous scope management and async handling
// ---------------------------------------------------------------------------
assert.strictEqual(internals.T, null);
let transitionInside = null;
let callbackExecuted = false;

const syncResult = startTransition(() => {
  callbackExecuted = true;
  transitionInside = internals.T;
});

assert.strictEqual(callbackExecuted, true);
assert.strictEqual(syncResult, undefined);
assert.ok(transitionInside !== null && typeof transitionInside === 'object');
assert.ok(transitionInside._updatedFibers instanceof Set);
assert.strictEqual(internals.T, null);

// startTransition with async callback returns undefined
let asyncExecuted = false;
const asyncTransitionReturn = startTransition(async () => {
  await new Promise((resolve) => setTimeout(resolve, 5));
  asyncExecuted = true;
});
assert.strictEqual(asyncTransitionReturn, undefined);

// ---------------------------------------------------------------------------
// Contract 4: use(Context) conditional reading and Context value resolution
// ---------------------------------------------------------------------------
const ThemeContext = createContext('light-default');
const AuthContext = createContext({ user: 'anonymous', authenticated: false });

const mockDispatcher = {
  use(usable) {
    if (usable !== null && typeof usable === 'object') {
      if (typeof usable.then === 'function') {
        if (usable.status === 'fulfilled') {
          return usable.value;
        }
        if (usable.status === 'rejected') {
          throw usable.reason;
        }
        throw usable;
      }
      if (usable.$$typeof === Symbol.for('react.context')) {
        return usable._currentValue;
      }
    }
    throw new Error(`An unsupported type was passed to use(): ${String(usable)}`);
  },
  useActionState(action, initialState, permalink) {
    let currentState = initialState;
    let isPending = false;
    const formAction = async (payload) => {
      isPending = true;
      currentState = await action(currentState, payload);
      isPending = false;
      return currentState;
    };
    return [currentState, formAction, isPending];
  },
  useOptimistic(passthrough, updateFn) {
    let currentOptimistic = passthrough;
    const setOptimistic = (updateArg) => {
      currentOptimistic = updateFn(currentOptimistic, updateArg);
    };
    return [currentOptimistic, setOptimistic];
  }
};

internals.H = mockDispatcher;

// Test context reading through use()
assert.strictEqual(use(ThemeContext), 'light-default');
assert.deepStrictEqual(use(AuthContext), { user: 'anonymous', authenticated: false });

// Test conditional reading pattern enabled by use()
function conditionallyReadContext(mode) {
  if (mode === 'theme') {
    return use(ThemeContext);
  }
  if (mode === 'auth') {
    return use(AuthContext);
  }
  return 'none';
}

assert.strictEqual(conditionallyReadContext('theme'), 'light-default');
assert.deepStrictEqual(conditionallyReadContext('auth'), { user: 'anonymous', authenticated: false });
assert.strictEqual(conditionallyReadContext('other'), 'none');

// ---------------------------------------------------------------------------
// Contract 5: use(Promise) suspension, resolved value unwrapping, and rejection
// ---------------------------------------------------------------------------
// Fulfilled promise synchronously unwraps value
const fulfilledPromise = {
  then(onFulfilled) {},
  status: 'fulfilled',
  value: { id: 101, title: 'React 19 Hooks' }
};
const unwrapped = use(fulfilledPromise);
assert.deepStrictEqual(unwrapped, { id: 101, title: 'React 19 Hooks' });

// Pending promise suspends (throws the promise instance)
const pendingPromise = {
  then(onFulfilled, onRejected) {},
  status: 'pending'
};
assert.throws(
  () => use(pendingPromise),
  (thrown) => thrown === pendingPromise
);

// Rejected promise throws the rejection error reason
const expectedError = new Error('Async computation failed');
const rejectedPromise = {
  then(onFulfilled, onRejected) {},
  status: 'rejected',
  reason: expectedError
};
assert.throws(
  () => use(rejectedPromise),
  (thrown) => thrown === expectedError
);

// Invalid type passed to use() throws descriptive error
assert.throws(
  () => use('invalid-string'),
  {
    name: 'Error',
    message: /An unsupported type was passed to use\(\): invalid-string/
  }
);
assert.throws(
  () => use(42),
  {
    name: 'Error',
    message: /An unsupported type was passed to use\(\): 42/
  }
);

// ---------------------------------------------------------------------------
// Contract 6: useActionState action dispatch, state progression, and pending state
// ---------------------------------------------------------------------------
const counterAction = async (prevState, amount) => {
  return prevState + amount;
};

const [initialCount, dispatchCounter, counterPending] = useActionState(counterAction, 100);
assert.strictEqual(initialCount, 100);
assert.strictEqual(typeof dispatchCounter, 'function');
assert.strictEqual(counterPending, false);

const nextCount = await dispatchCounter(25);
assert.strictEqual(nextCount, 125);

// ---------------------------------------------------------------------------
// Contract 7: useOptimistic optimistic state derivation
// ---------------------------------------------------------------------------
const optimisticUpdater = (state, newTitle) => ({ ...state, title: newTitle, sending: true });
const [optimisticMessage, setOptimistic] = useOptimistic(
  { id: 1, title: 'Original Message', sending: false },
  optimisticUpdater
);

assert.deepStrictEqual(optimisticMessage, { id: 1, title: 'Original Message', sending: false });
assert.strictEqual(typeof setOptimistic, 'function');

setOptimistic('Optimistic Title');
assert.deepStrictEqual(optimisticMessage, { id: 1, title: 'Original Message', sending: false });

// Clean up hook dispatcher
internals.H = null;