Run React 19 Source Desk from your own code

Both metered lanes are available over HTTP and each returns one JSON object. The division of labour: the page masks the JSX, finds every API React 19 removes or changes, and makes the mechanical changes itself - createRoot, ref props, default parameters, useRef(null), the propTypes note, then hands it all to the run as facts. The run writes the review or the rewrite; the page then holds it to its own facts and re-scans the upgraded file with the same scanner (r19reply.js).

Base URL and the response shape

Every endpoint lives under https://api.skillsafe.ai/v1/app-api, and every response has one shape:

{ "ok": true,  "data":  { ... } }
{ "ok": false, "error": { "code": "...", "message": "..." } }

The token is minted for this app (the guest call takes {"slug":"react19-source-desk"}), so no slug header is needed afterwards. Send it as Authorization: Bearer YOUR_TOKEN. The run body is the input object, sent bare.

The task field comes first

Two lanes, chosen by task, in the order the work runs - inspect, then produce:

• review - each of the page's findings confirmed (with the issue, the fix and a short code fix) or cleared (with why), up to five issues a scan cannot see on real lines, and the fixes in the order to make them, each naming its ids.
• rewrite - the whole file on React 19 - createRoot and hydrateRoot, root.unmount(), direct refs instead of findDOMNode, ref as a prop, default parameters, useRef(null) - with what changed and what was kept, every component name unchanged.

A missing or unknown task is answered as review. Both lanes send the same five fields. The facts are the page's scan, one finding per line with its id, and a line starting "must:" is a rule the reply has to hold. The page's handoff carries the review's decisions into carry for the rewrite lane. The review sends at most 24,000 characters of code (the middle of a longer file is cut on whole lines and marked; every finding is still in the facts); the rewrite lane takes at most 16,000.

The input

The rules the model applies

From the source skill, @github/react19-source-patterns - the only standard the run applies:

• ReactDOM.render(element, container) becomes const root = createRoot(container); root.render(element), from react-dom/client. ReactDOM.hydrate(element, container) becomes hydrateRoot(container, element). unmountComponentAtNode(container) becomes root.unmount() on the root createRoot returned - if the root was never saved, pass it around or keep it in a module-level registry.
• findDOMNode is removed: put a ref on the element and read ref.current (a createRef field in a class, useRef(null) in a function component).
• forwardRef is optional modernization in React 19: a function component accepts ref as a regular prop - function Input({ ref, ...props }). useImperativeHandle(ref, ...) still works; only the wrapper goes.
• defaultProps are removed for function components: ES6 default parameters in the destructured props are the only way (function Button({ label = 'Click', disabled = false })); a null default becomes value = null or value ?? null. The page adds one correction from React itself: class components keep static defaultProps in React 19, so they are left alone.
• useRef() with no argument becomes useRef(null).
• Legacy context (contextTypes, childContextTypes, getChildContext) and string refs are completely removed - createContext with static contextType or useContext, and createRef or useRef(null).
• Do not remove propTypes: the prop-types package still works as a standalone validator, React just no longer runs the checks. Keep the block, with the note: // NOTE: React 19 no longer runs propTypes validation at runtime. // PropTypes kept for documentation and IDE tooling only.
• Remove import React from 'react' only when nothing in the file uses React. - and only when the build uses the automatic JSX runtime.

House rules

• Use only the input. Never invent a prop, a component, a module or a file the code does not hold; React and react-dom APIs a fix needs (createRoot, hydrateRoot, useRef, useImperativeHandle) are fine. When a fix needs another file (where the root is created, the provider of a legacy context, the component a ref is passed to), say so in a caveat.
• The page's ids and lines are measured facts: never renumber an id. For a finding the page already migrated, confirm it (with the page's change as the fix) or clear it with the reason the change is wrong for this code.
• No web links (http or https) in prose.
• Write in English. Keep the JSON keys and the ids exactly as given.
• Never use backticks. Name calls plainly (createRoot(container).render(element), useRef(null)). Words from the rules above are free to use; what you never do is paste a whole sentence from this prompt.
• Never write a gendered pronoun for a user; write they, the user or the person.
• Reply with ONLY one JSON object - no prose before or after, no code fences.

The replies

review

Confirm or clear each of the page's findings, decide what the page left, add what a scan cannot see, and put the steps in order.

1. summary - one sentence, at most 40 words: what breaks on React 19 today, what the page already changed, and the first step.
2. findings - one object per page finding you confirm, in id order: id (the page's id), widget (where it sits, e.g. "Button" or "the entry point"), issue (one sentence: what goes wrong on React 19), fix (one sentence: the change), code (the React 19 lines for that piece only, at most 6; "" when fix says it all).
3. cleared - one object per page finding that is not a problem here, with id and why (one sentence tied to the code). Every page id appears exactly once, in findings or in cleared.
4. extra - at most 5 issues the scan cannot see, each tied to a line of the code: id (X1, X2, ...), area (root, dom, refs, props, removed or imports), line (a number), widget, issue, fix. Examples: a render callback that must become an effect, a root created twice (once per hot reload), a default read from props elsewhere, a ref forwarded into a child that is still a class, a typed forwardRef whose props type must gain ref. [] when there are none.
5. plan - 2 to 10 short strings, the steps in order (what React 19 removes first - the root API, findDOMNode, defaultProps, legacy context and string refs - then refs and the rest), each naming the ids it covers (e.g. "Switch the entry point to createRoot (N1)"). Every confirmed id appears in a step. [] only when nothing is confirmed.
6. caveats - at most 4 short strings; [] when there is nothing to say.

{
  "task": "review",
  "summary": "one sentence",
  "findings": [ { "id": "N1", "widget": "the entry point", "issue": "one sentence", "fix": "one sentence", "code": "const root = createRoot(container);\nroot.render(<App />);" } ],
  "cleared": [ { "id": "N3", "why": "one sentence" } ],
  "extra": [ { "id": "X1", "area": "root", "line": 15, "widget": "the entry point", "issue": "one sentence", "fix": "one sentence" } ],
  "plan": [ "Switch the entry point to createRoot (N1)" ],
  "caveats": [ ]
}

The page holds it to its own facts (check() in r19reply.js; any warning makes the reply flagged): the reply answers the task it was sent; every page finding id appears exactly once across findings and cleared, and no id the page never found; a cleared id has a reason; a confirmed id has an issue and a fix; at most five extra issues, each on a line inside the paste; a fix order of 2 to 10 steps that names every confirmed id; a summary; no web link in the prose.

rewrite

Rewrite the whole file on React 19.

1. summary - one sentence, at most 40 words: what the rewrite changed and what it left for the team.
2. code - the complete React 19 file. Keep every import that is still used, every component and class (by name), every export and prop; change only what the findings name, plus every carried extra whose fix lives in this file (list it in changes; one that needs another file goes in a caveat), plus the imports a change needs, and drop an import the change leaves unused. Never shorten the file with "..." or "unchanged" - write every line. If the code holds a line starting "// [... N lines cut by the page", keep that line exactly where it is. The root - createRoot / hydrateRoot from react-dom/client; keep the root in a const when it is unmounted, and replace unmountComponentAtNode with root.unmount(). findDOMNode - a ref on the element, read as ref.current. forwardRef - ref as a prop (for TypeScript, add ref to the props type: ref?: React.Ref<HTMLDivElement>), useImperativeHandle untouched. Function-component defaultProps - default parameters in the destructured props, the assignment deleted. useRef() - useRef(null); propTypes - kept with the note. Legacy context and string refs - createContext and createRef / useRef(null), saying in a caveat which other files change with it.
3. changes - one object per page finding you acted on (including the ones the page already migrated, which the rewrite keeps), in id order: id, change (one sentence: what changed, naming where). Extra ids (X1, ...) from the carried review may appear too.
4. kept - one object per page finding you did not change: id, why (one sentence - the review cleared it, or it needs a file the paste does not hold). Every page id appears exactly once, in changes or in kept; an id the carried review cleared belongs in kept.
5. caveats - at most 4 short strings; [] when there is nothing to say.

{
  "task": "rewrite",
  "summary": "one sentence",
  "code": "the complete React 19 file",
  "changes": [ { "id": "N1", "change": "one sentence" } ],
  "kept": [ { "id": "N3", "why": "one sentence" } ],
  "caveats": [ ]
}

The page requires: the reply answers the task it was sent; every page finding id appears exactly once across changes and kept; every component survives; the file is not shortened (at least 70% of its lines) and elides nothing; and the rewritten code is scanned again - a rule the changes claim fixed that still fires, or a rule the paste never had, is flagged. A component the rewrite drops or renames is flagged.

Worked examples

Three runs from the page's free samples (invented apps): the review of a component kit on forwardRef and defaultProps, the rewrite of the same file carrying that review, and the review of an entry point still on ReactDOM.render. Each input is exactly what the page sends; each reply is the saved reply the sample replays, shipped unedited - but the code, the facts and long strings are shortened in this display only, and every cut is listed under the example. The last line is the page's own check of the full reply.

review - A component kit on forwardRef and defaultProps

The page read it as: Breaks on React 19 - 1 blocker, 1 major, 4 minor; findings N1 unused-react-import, N2 forward-ref, N3 useref-no-arg, N4 default-props, N5 prop-types, N6 forward-ref.

Input (facts is 1682 characters; the first 1397 are shown):

{
 "task": "review",
 "unit": "File: src/ui/kit.jsx\nKind: a shared component library file",
 "code": "import React, { forwardRef, useRef, useImperativeHandle } from \"react\";\nimport PropTypes from \"prop-types\";\n\nexport const TextField = forwardRef((props, ref) => {\n  const inputRef = useRef();\n  useImperativeHandle(ref, () => ({\n    focus: () => inputRef.current.focus(),\n    clear: () => { inputRef.current.value = \"\"; },\n  }));\n  return <input ref={inputRef} className=\"field\" {...props} />;\n});\n\nexport function Button({ label, variant, disabled, onClick }) {\n  return (\n    <button className={\"btn btn-\" + variant} disabled={disabled} onClick={onClick}>\n      {label}\n    </button>\n  );\n}\n\nButton.defaultProps = {\n  label: \"Save\",\n  variant: \"primary\",\n  disabled: false,\n};\n\nButton.propTypes = {\n  label: PropTypes.string,\n  variant: PropTypes.oneOf([\"primary\", \"ghost\"]),\n  disabled: PropTypes.bool,\n  onClick: PropTypes.func,\n};\n\nexport const Icon = forwardRef(({ name, size }, ref) => (\n  <svg ref={ref} width={size} height={size} aria-hidden=\"true\"><use href={\"#\" + name} /></svg>\n));\n",
 "carry": "",
 "facts": "The page's scan of 37 lines - 3 components (TextField, Button, Icon); 5 of 6 findings migrated by the page; verdict: Breaks on React 19.\nFindings (id | area | severity | line | where | evidence | source | what the page did):\n- N1 | imports | minor | line 1 | the file | The default React import is not used as React.* anywhere in the file. | source: import React, { forwardRef, useRef, useImperativeHandle } from \"react\"; | left\n- N2 | refs | minor | line 4 | TextField | forwardRef wraps TextField - in React 19 a function component takes ref as a plain prop, so the wrapper is no longer needed. | source: export const TextField = forwardRef((props, ref) => { | migrated\n- N3 | refs | major | line 5 | TextField | useRef() with no initial value - React 19's types require an argument, and the ref starts undefined rather than null. | source: const inputRef = useRef(); | migrated\n- N4 | props | blocker | line 21 | Button | Button.defaultProps is ignored for function components in React 19 - every default (label, variant, disabled) silently becomes undefined. | source: Button.defaultProps = { | migrated\n- N5 | props | minor | line 27 | Button | React 19 no longer runs propTypes validation at runtime - the prop-types package still works as a standalone validator, so the block stays. | source: Button.propTypes = { | migrated\n- N6 | refs | minor | line 34 | Icon | forwardRef wraps Icon - in\n\n[... 285 more characters cut from this display ...]"
}

Reply:

{
 "task": "review",
 "summary": "On React 19 the Button defaults vanish and useRef() fails the types; the page already rewrote defaults, refs, forwardRef and the propTypes note, and the first step is moving the Button defaults into its parameters.",
 "findings": [
  {
   "id": "N2",
   "widget": "TextField",
   "issue": "The forwardRef wrapper is no longer needed because a React 19 function component receives ref as a prop.",
   "fix": "Turn TextField into a function that destructures ref from its props and passes it to useImperativeHandle unchanged.",
   "code": "export function TextField({ ref, ...props }) {\n  const inputRef = useRef(null);\n  useImperativeHandle(ref, () => ({\n    focus: () => inputRef.current.focus(),\n    clear: () => { inputRef.current.value = \"\"; },\n  }));"
  },
  {
   "id": "N3",
   "widget": "TextField",
   "issue": "useRef() with no argument starts undefined and no longer satisfies the React 19 types.",
   "fix": "Initialise the input ref with useRef(null).",
   "code": "const inputRef = useRef(null);"
  },
  {
   "id": "N4",
   "widget": "Button",
   "issue": "Button.defaultProps is ignored for function components, so label, variant and disabled arrive undefined.",
   "fix": "Move the three defaults into the destructured parameters and delete the Button.defaultProps assignment.",
   "code": "export function Button({ label = \"Save\", variant = \"primary\", disabled = false, onClick }) {"
  },
  {
   "id": "N5",
   "widget": "Button",
   "issue": "React 19 no longer runs the Button.propTypes checks, so the block only documents the props.",
   "fix": "Keep Button.propTypes and add the React 19 note above it.",
   "code": "// NOTE: React 19 no longer runs propTypes validation at runtime.\n// PropTypes kept for documentation and IDE tooling only.\nButton.propTypes = {"
  },
  {
   "id": "N6",
   "widget": "Icon",
   "issue": "The forwardRef wrapper around Icon is no longer needed because ref arrives as a prop in React 19.",
   "fix": "Turn Icon into a function that destructures name, size and ref and puts ref on the svg.",
   "code": "export function Icon({ name, size, ref }) {\n  return (\n    <svg ref={ref} width={size} height={size} aria-hidden=\"true\"><use href={\"#\" + name} /></svg>\n  );\n}"
  }
 ],
 "cleared": [
  {
   "id": "N1",
   "why": "The file is JSX with no visible build setup, so the default React import may still be what the classic JSX transform needs, and it also carries the named hook imports."
  }
 ],
 "extra": [
  {
   "id": "X1",
   "area": "imports",
   "line": 1,
   "widget": "the file",
   "issue": "After both forwardRef wrappers go, forwardRef stays in the named import with nothing using it.",
   "fix": "Drop forwardRef from the react import and keep useRef and useImperativeHandle."
  }
 ],
 "plan": [
  "Move the Button defaults into its destructured parameters and delete Button.defaultProps (N4)",
  "Switch the TextField input ref to useRef(null) (N3)",
  "Take ref as a prop in TextField and Icon instead of forwardRef (N2, N6)",
  "Remove forwardRef from the react import (X1)",
  "Add the React 19 note above Button.propTypes and keep the block (N5)"
 ],
 "caveats": [
  "Callers that relied on Button.defaultProps being read from props elsewhere should be checked in their own files."
 ]
}

What step 5 prints for it: N2: Turn TextField into a function that destructures ref from its props and passes it to useImperativeHandle unchanged. | N3: Initialise the input ref with useRef(null). | N4: Move the three defaults into the destructured parameters and delete the Button.defaultProps assignment. | N5: Keep Button.propTypes and add the React 19 note above it. | N6: Turn Icon into a function that destructures name, size and ref and puts ref on the svg. | N1: cleared

The page's check: kept - X1 repeats what the page already found on line 1.

rewrite - A component kit on forwardRef and defaultProps

The input carries the saved review (R.laneForm fills carry from the review reply), as the page's handoff does. The page re-scanned the rewritten code: 6 findings before, 1 after.

Input (facts is 1674 characters; the first 1397 are shown):

{
 "task": "rewrite",
 "unit": "File: src/ui/kit.jsx\nKind: a shared component library file",
 "code": "import React, { forwardRef, useRef, useImperativeHandle } from \"react\";\nimport PropTypes from \"prop-types\";\n\nexport const TextField = forwardRef((props, ref) => {\n  const inputRef = useRef();\n  useImperativeHandle(ref, () => ({\n    focus: () => inputRef.current.focus(),\n    clear: () => { inputRef.current.value = \"\"; },\n  }));\n  return <input ref={inputRef} className=\"field\" {...props} />;\n});\n\nexport function Button({ label, variant, disabled, onClick }) {\n  return (\n    <button className={\"btn btn-\" + variant} disabled={disabled} onClick={onClick}>\n      {label}\n    </button>\n  );\n}\n\nButton.defaultProps = {\n  label: \"Save\",\n  variant: \"primary\",\n  disabled: false,\n};\n\nButton.propTypes = {\n  label: PropTypes.string,\n  variant: PropTypes.oneOf([\"primary\", \"ghost\"]),\n  disabled: PropTypes.bool,\n  onClick: PropTypes.func,\n};\n\nexport const Icon = forwardRef(({ name, size }, ref) => (\n  <svg ref={ref} width={size} height={size} aria-hidden=\"true\"><use href={\"#\" + name} /></svg>\n));\n",
 "carry": "N2 | confirmed | TextField | Turn TextField into a function that destructures ref from its props and passes it to useImperativeHandle unchanged.\nN3 | confirmed | TextField | Initialise the input ref with useRef(null).\nN4 | confirmed | Button | Move the three defaults into the destructured parameters and delete the Button.defaultProps assignment.\nN5 | confirmed | Button | Keep Button.propTypes and add the React 19 note above it.\nN6 | confirmed | Icon | Turn Icon into a function that destructures name, size and ref and puts ref on the svg.\nN1 | cleared | - | The file is JSX with no visible build setup, so the default React import may still be what the classic JSX transform needs, and it also carries the named hook imports.\nX1 | extra | the file (line 1) | Drop forwardRef from the react import and keep useRef and useImperativeHandle.",
 "facts": "The page's scan of 37 lines - 3 components (TextField, Button, Icon); 5 of 6 findings migrated by the page; verdict: Breaks on React 19.\nFindings (id | area | severity | line | where | evidence | source | what the page did):\n- N1 | imports | minor | line 1 | the file | The default React import is not used as React.* anywhere in the file. | source: import React, { forwardRef, useRef, useImperativeHandle } from \"react\"; | left\n- N2 | refs | minor | line 4 | TextField | forwardRef wraps TextField - in React 19 a function component takes ref as a plain prop, so the wrapper is no longer needed. | source: export const TextField = forwardRef((props, ref) => { | migrated\n- N3 | refs | major | line 5 | TextField | useRef() with no initial value - React 19's types require an argument, and the ref starts undefined rather than null. | source: const inputRef = useRef(); | migrated\n- N4 | props | blocker | line 21 | Button | Button.defaultProps is ignored for function components in React 19 - every default (label, variant, disabled) silently becomes undefined. | source: Button.defaultProps = { | migrated\n- N5 | props | minor | line 27 | Button | React 19 no longer runs propTypes validation at runtime - the prop-types package still works as a standalone validator, so the block stays. | source: Button.propTypes = { | migrated\n- N6 | refs | minor | line 34 | Icon | forwardRef wraps Icon - in\n\n[... 277 more characters cut from this display ...]"
}

Reply (long strings shortened for display - see the cuts below):

{
 "task": "rewrite",
 "summary": "TextField and Icon take ref as a prop, the input ref starts at null, Button defaults moved into its parameters and propTypes carry the React 19 note; the default React import is left for the team's JSX runtime check.",
 "code": "import React, { useRef, useImperativeHandle } from \"react\";\nimport PropTypes from \"prop-types\";\n\nexport function TextField({ ref, ...props }) {\n  const inputRef = useRef(null);\n  useImperativeHandle(ref, () => ({\n    focus: () => inputRef.current.focus(),\n    clear: () => { inputRef.current.value = \"\"; },\n  })); [... 732 more characters cut from this display]",
 "changes": [
  {
   "id": "N2",
   "change": "TextField is a plain function that takes ref from its props and hands it to useImperativeHandle."
  },
  {
   "id": "N3",
   "change": "The TextField input ref now starts with useRef(null)."
  },
  {
   "id": "N4",
   "change": "Button takes its label, variant and disabled defaults as parameter defaults and Button.defaultProps is gone."
  },
  {
   "id": "N5",
   "change": "Button.propTypes is kept with the React 19 note above it."
  },
  {
   "id": "N6",
   "change": "Icon is a plain function that takes ref with name and size and puts it on the svg."
  },
  {
   "id": "X1",
   "change": "forwardRef was dropped from the react import, which keeps useRef and useImperativeHandle."
  }
 ],
 "kept": [
  {
   "id": "N1",
   "why": "The review cleared it because the default React import may still be needed by a classic JSX transform."
  }
 ],
 "caveats": [
  "Remove the default React import only once the build is confirmed to use the automatic JSX runtime."
 ]
}

Cut from this display only (the saved reply and the check use the full text): code (1045 characters, 313 shown).

What step 5 prints for it: N2: TextField is a plain function that takes ref from its props and hands it to useImperativeHandle. | N3: The TextField input ref now starts with useRef(null). | N4: Button takes its label, variant and disabled defaults as parameter defaults and Button.defaultProps is gone. | N5: Button.propTypes is kept with the React 19 note above it. | N6: Icon is a plain function that takes ref with name and size and puts it on the svg. | X1: forwardRef was dropped from the react import, which keeps useRef and useImperativeHandle.

The page's check: kept - nothing to flag

review - An entry point still on ReactDOM.render

The page read it as: Breaks on React 19 - 2 blocker, 0 major, 0 minor; findings N1 legacy-root, N2 unmount-node.

Input:

{
 "task": "review",
 "unit": "File: src/index.jsx\nKind: the app's entry point",
 "code": "import React from \"react\";\nimport ReactDOM from \"react-dom\";\nimport App from \"./App\";\nimport \"./index.css\";\n\nconst container = document.getElementById(\"root\");\n\nReactDOM.render(\n  <React.StrictMode>\n    <App />\n  </React.StrictMode>,\n  container\n);\n\nif (module.hot) {\n  module.hot.dispose(() => ReactDOM.unmountComponentAtNode(container));\n}\n",
 "carry": "",
 "facts": "The page's scan of 18 lines - 0 components (none); 1 of 2 findings migrated by the page; verdict: Breaks on React 19.\nFindings (id | area | severity | line | where | evidence | source | what the page did):\n- N1 | root | blocker | line 8 | the entry point | ReactDOM.render(...) is removed in React 19 - every app needs createRoot from react-dom/client. | source: ReactDOM.render( | migrated\n- N2 | root | blocker | line 16 | the entry point | unmountComponentAtNode is removed in React 19 - a root is unmounted through the object createRoot returned. | source: module.hot.dispose(() => ReactDOM.unmountComponentAtNode(container)); | left\nmust: account for every finding id above exactly once - in findings (confirmed) or in cleared (with the reason)."
}

Reply:

{
 "task": "review",
 "summary": "On React 19 the ReactDOM.render call and the hot-reload unmountComponentAtNode both fail; the page already moved rendering to createRoot, and the first step is saving that root so the dispose handler can unmount it.",
 "findings": [
  {
   "id": "N1",
   "widget": "the entry point",
   "issue": "ReactDOM.render no longer exists in React 19, so the app never mounts.",
   "fix": "Create the root with createRoot(container) from react-dom/client and call root.render with the StrictMode tree.",
   "code": "const root = createRoot(container);\nroot.render(\n  <React.StrictMode>\n    <App />\n  </React.StrictMode>\n);"
  },
  {
   "id": "N2",
   "widget": "the entry point",
   "issue": "ReactDOM.unmountComponentAtNode is gone in React 19, so the hot-reload dispose handler throws.",
   "fix": "Keep the root from createRoot in a const and call root.unmount() inside module.hot.dispose.",
   "code": "if (module.hot) {\n  module.hot.dispose(() => root.unmount());\n}"
  }
 ],
 "cleared": [],
 "extra": [
  {
   "id": "X1",
   "area": "imports",
   "line": 2,
   "widget": "the entry point",
   "issue": "Once both calls move to the client API, the default react-dom import is left with nothing to provide.",
   "fix": "Replace the react-dom import with import { createRoot } from \"react-dom/client\"."
  }
 ],
 "plan": [
  "Import createRoot from react-dom/client in place of the default react-dom import (X1)",
  "Render the StrictMode tree through a root saved in a const (N1)",
  "Unmount that saved root in the hot-reload dispose handler (N2)",
  "Run the app and trigger a hot reload to confirm one root mounts each time (N1, N2)"
 ],
 "caveats": [
  "React stays imported because the file still reads React.StrictMode."
 ]
}

What step 5 prints for it: N1: Create the root with createRoot(container) from react-dom/client and call root.render with the StrictMode tree. | N2: Keep the root from createRoot in a const and call root.unmount() inside module.hot.dispose.

The page's check: kept - nothing to flag

Build the input yourself

Load the engine in node (global.window = global; require("./r19kit.js"); require("./r19reply.js")), then:

const K = R19Kit, R = R19Reply;
const f = K.form({ name: "src/Btn.jsx", targets: "component", carry: "",
  code: "export const Btn = forwardRef((props, ref) => <button ref={ref} {...props} />);\nexport function Tag({ text }) { return <b>{text}</b>; }\nTag.defaultProps = { text: \"new\" };" });
// f.findings (each with .auto when the page migrated it), f.scan.migrated (the React 19 file), f.checklist
// K.findingsCsv(f), K.itemsCsv(f), K.checklistMd(f) - the free exports
const b = K.buildInput(f, "review");                         // or "rewrite" (R.laneForm(form, "rewrite", review) fills carry)
const wire = K.toWire(b.input);                              // POST this to /estimate and /run
// then: const reply = R.normalize(R.parseReply(job.output.output), "review");
// R.check(reply, b)                                         // {status: kept or flags, notes}

Get a token for the steps below from /tokens.html.

Step 1 — a tiny client helper

One function that sends JSON and unwraps the response. Paste a personal token from /tokens.html, or leave it empty and mint a guest token in step 2.

BASE="https://api.skillsafe.ai/v1/app-api"
TOKEN="YOUR_TOKEN"   # from https://react19-source-desk.skillsafe.ai/tokens.html
api() { # api METHOD PATH [JSON-BODY]
  curl -s -X "$1" "$BASE$2" -H "Content-Type: application/json" \
    ${TOKEN:+-H "Authorization: Bearer $TOKEN"} ${3:+--data "$3"}
}

import json, urllib.request

BASE = "https://api.skillsafe.ai/v1/app-api"
TOKEN = "YOUR_TOKEN"  # from https://react19-source-desk.skillsafe.ai/tokens.html

def api(method, path, body=None, headers=None):
    req = urllib.request.Request(BASE + path, method=method,
        data=None if body is None else json.dumps(body).encode(),
        headers={"Content-Type": "application/json", **({"Authorization": "Bearer " + TOKEN} if TOKEN else {}), **(headers or {})})
    with urllib.request.urlopen(req) as r:
        env = json.load(r)
    if env.get("error"):
        raise RuntimeError(env["error"])
    return env["data"]

// react19-source-desk.mjs -- Node 18+ (global fetch)
const BASE = "https://api.skillsafe.ai/v1/app-api";
let TOKEN = "YOUR_TOKEN"; // from https://react19-source-desk.skillsafe.ai/tokens.html
async function api(method, path, body, headers = {}) {
  const r = await fetch(BASE + path, { method, headers: { "Content-Type": "application/json",
    ...(TOKEN ? { Authorization: "Bearer " + TOKEN } : {}), ...headers },
    body: body === undefined ? undefined : JSON.stringify(body) });
  const env = await r.json();
  if (env.error) throw new Error(env.error.code + ": " + env.error.message);
  return env.data;
}

package main

import ("bytes"; "encoding/json"; "fmt"; "net/http")

const base = "https://api.skillsafe.ai/v1/app-api"
var token = "YOUR_TOKEN" // from https://react19-source-desk.skillsafe.ai/tokens.html

func api(method, path string, body any, headers map[string]string) (map[string]any, error) {
	var buf bytes.Buffer
	if body != nil { json.NewEncoder(&buf).Encode(body) }
	req, _ := http.NewRequest(method, base+path, &buf)
	req.Header.Set("Content-Type", "application/json")
	if token != "" { req.Header.Set("Authorization", "Bearer "+token) }
	for k, v := range headers { req.Header.Set(k, v) }
	res, err := http.DefaultClient.Do(req)
	if err != nil { return nil, err }
	defer res.Body.Close()
	var env struct { Data map[string]any; Error map[string]any }
	json.NewDecoder(res.Body).Decode(&env)
	if env.Error != nil { return nil, fmt.Errorf("%v", env.Error) }
	return env.Data, nil
}

// React19SourceDesk.java -- Java 17+, with com.fasterxml.jackson.core:jackson-databind
import com.fasterxml.jackson.databind.*;
import java.net.URI; import java.net.http.*; import java.util.*;

public class React19SourceDesk {
  static final String BASE = "https://api.skillsafe.ai/v1/app-api";
  static String token = "YOUR_TOKEN"; // from https://react19-source-desk.skillsafe.ai/tokens.html
  static final ObjectMapper M = new ObjectMapper();
  static final HttpClient C = HttpClient.newHttpClient();
  static JsonNode api(String method, String path, Object body, Map<String, String> headers) throws Exception {
    var b = HttpRequest.newBuilder(URI.create(BASE + path)).header("Content-Type", "application/json");
    if (!token.isEmpty()) b.header("Authorization", "Bearer " + token);
    if (headers != null) headers.forEach(b::header);
    b.method(method, body == null ? HttpRequest.BodyPublishers.noBody() : HttpRequest.BodyPublishers.ofString(M.writeValueAsString(body)));
    JsonNode env = M.readTree(C.send(b.build(), HttpResponse.BodyHandlers.ofString()).body());
    if (env.hasNonNull("error")) throw new RuntimeException(env.get("error").toString());
    return env.get("data");
  }
}

require "json"
require "net/http"

BASE = "https://api.skillsafe.ai/v1/app-api"
TOKEN = "YOUR_TOKEN" # from https://react19-source-desk.skillsafe.ai/tokens.html

def api(method, path, body = nil, headers = {})
  uri = URI(BASE + path)
  req = Net::HTTPGenericRequest.new(method, !body.nil?, true, uri.request_uri,
    { "Content-Type" => "application/json" }.merge(TOKEN.empty? ? {} : { "Authorization" => "Bearer #{TOKEN}" }).merge(headers))
  req.body = JSON.generate(body) unless body.nil?
  env = JSON.parse(Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }.body)
  raise env["error"].to_s if env["error"]
  env["data"]
end

<?php
const BASE = "https://api.skillsafe.ai/v1/app-api";
$TOKEN = "YOUR_TOKEN"; // from https://react19-source-desk.skillsafe.ai/tokens.html

function api(string $method, string $path, $body = null, array $headers = []) {
    global $TOKEN;
    $h = ["Content-Type: application/json"];
    if ($TOKEN) $h[] = "Authorization: Bearer $TOKEN";
    foreach ($headers as $k => $v) $h[] = "$k: $v";
    $ch = curl_init(BASE . $path);
    curl_setopt_array($ch, [CURLOPT_CUSTOMREQUEST => $method, CURLOPT_HTTPHEADER => $h, CURLOPT_RETURNTRANSFER => true]);
    if ($body !== null) curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
    $env = json_decode(curl_exec($ch), true);
    if (!empty($env["error"])) throw new Exception(json_encode($env["error"]));
    return $env["data"];
}

// Program.cs -- .NET 6+ console app
using System.Net.Http.Json; using System.Text.Json; using System.Text.Json.Nodes;

static class Api {
  public const string Base = "https://api.skillsafe.ai/v1/app-api";
  public static string Token = "YOUR_TOKEN"; // from https://react19-source-desk.skillsafe.ai/tokens.html
  static readonly HttpClient C = new();
  public static async Task<JsonNode?> Call(string method, string path, object? body = null, Dictionary<string, string>? headers = null) {
    var req = new HttpRequestMessage(new HttpMethod(method), Base + path);
    if (Token != "") req.Headers.Add("Authorization", "Bearer " + Token);
    if (headers != null) foreach (var h in headers) req.Headers.Add(h.Key, h.Value);
    if (body != null) req.Content = JsonContent.Create(body);
    var env = JsonNode.Parse(await (await C.SendAsync(req)).Content.ReadAsStringAsync())!;
    if (env["error"] is JsonNode e && e.GetValueKind() != JsonValueKind.Null) throw new Exception(e.ToJsonString());
    return env["data"];
  }
}

Step 2 — a token

A guest token is enough for /me and /estimate. A run is metered, so it needs a personal token: sign in on /tokens.html and copy it from there.

# a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
TOKEN=$(curl -s -X POST "$BASE/guest" -H "Content-Type: application/json" -d '{"slug":"react19-source-desk"}' | jq -r '.data.token')

# a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
TOKEN = ""
TOKEN = api("POST", "/guest", {"slug": "react19-source-desk"})["token"]

// a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
TOKEN = "";
TOKEN = (await api("POST", "/guest", { slug: "react19-source-desk" })).token;

// inside main: a guest token (enough for /me and /estimate); a run needs your personal token
token = ""
g, err := api("POST", "/guest", map[string]string{"slug": "react19-source-desk"}, nil)
if err != nil { panic(err) }
token = g["token"].(string)

// inside main: a guest token (enough for /me and /estimate); a run needs your personal token
token = "";
token = api("POST", "/guest", Map.of("slug", "react19-source-desk"), null).get("token").asText();

# a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
TOKEN.replace("")
TOKEN.replace(api("POST", "/guest", { slug: "react19-source-desk" })["token"])

// a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
$TOKEN = "";
$TOKEN = api("POST", "/guest", ["slug" => "react19-source-desk"])["token"];

// a guest token (enough for /me and /estimate); a run needs your personal token from /tokens.html
Api.Token = "";
Api.Token = (await Api.Call("POST", "/guest", new { slug = "react19-source-desk" }))!["token"]!.GetValue<string>();

Step 3 — GET /me

Who the token is (subject_type: user or guest) and the credit balance.

api GET /me | jq '.data | {subject_type, credits}' 

me = api("GET", "/me")
print(me["subject_type"], me.get("credits"))

const me = await api("GET", "/me");
console.log(me.subject_type, me.credits);

me, _ := api("GET", "/me", nil, nil)
fmt.Println(me["subject_type"], me["credits"])

JsonNode me = api("GET", "/me", null, null);
System.out.println(me.get("subject_type") + " " + me.get("credits"));

me = api("GET", "/me")
puts [me["subject_type"], me["credits"]].inspect

$me = api("GET", "/me");
echo $me["subject_type"], " ", $me["credits"] ?? "", "\n";

var me = await Api.Call("GET", "/me");
Console.WriteLine($"{me!["subject_type"]} {me["credits"]}");

Step 4 — POST /estimate

Free. The body is the run input itself, the bare object (never wrapped in {"input": ...}). hold_credits is a reservation, not the price; min_credits is what the balance must cover; model_alias reads gpt-terra.

# input.json: the run input object - {"task": "review", "unit": "File: src/ui/kit.jsx\nKind: a shared component library file", "code": "import React, { forwardRef, useRef, useImperativeHandle } from \"react\";\n...", "carry": "", "facts": "The page's scan of 54 lines - 3 components ...\nFindings (id | area | severity | line | where | evidence | source | what the page did):\n- N1 | imports | minor | line 1 | ..."}
# - see the input table
api POST /estimate "$(cat input.json)" | jq '.data | {hold_credits, min_credits, model, model_alias, markup_bps, warnings}' 

inp = json.load(open("input.json"))   # {"task": "review", "unit": "File: src/ui/kit.jsx\nKind: a shared component library file", "code": "import React, { forwardRef, useRef, useImperativeHandle } from \"react\";\n...", "carry": "", "facts": "The page's scan of 54 lines - 3 components ...\nFindings (id | area | severity | line | where | evidence | source | what the page did):\n- N1 | imports | minor | line 1 | ..."}
# - see the input table
est = api("POST", "/estimate", inp)
print(est["hold_credits"], est["min_credits"], est["model"], est.get("warnings"))

import { readFileSync } from "node:fs";
const input = JSON.parse(readFileSync("input.json", "utf8")); // {task: "review" or "rewrite", unit, code, carry, facts} (see the input table)
const est = await api("POST", "/estimate", input);
console.log(est.hold_credits, est.min_credits, est.model, est.warnings);

raw, _ := os.ReadFile("input.json") // add "os" to the imports
var input map[string]any
json.Unmarshal(raw, &input)
est, _ := api("POST", "/estimate", input, nil)
fmt.Println(est["hold_credits"], est["min_credits"], est["model"])

Map<String, Object> input = M.readValue(new java.io.File("input.json"), Map.class);
JsonNode est = api("POST", "/estimate", input, null);
System.out.println(est.get("hold_credits") + " " + est.get("min_credits") + " " + est.get("model"));

input = JSON.parse(File.read("input.json"))
est = api("POST", "/estimate", input)
puts [est["hold_credits"], est["min_credits"], est["model"]].inspect

$input = json_decode(file_get_contents("input.json"), true);
$est = api("POST", "/estimate", $input);
echo $est["hold_credits"], " ", $est["min_credits"], " ", $est["model"], "\n";

var input = JsonNode.Parse(File.ReadAllText("input.json"))!;
var est = await Api.Call("POST", "/estimate", input);
Console.WriteLine($"{est!["hold_credits"]} {est["min_credits"]} {est["model"]}");

Step 5 — POST /run, then poll the job

Send an Idempotency-Key built from the lane and the input: a retry with the same key never bills twice. The page uses react19-source-desk:<task>:<inputHash>:a<attempt> - the lane is part of the key, retry_note is left out of the hash - and its one automatic reformat retry is a new attempt number, named in the page as one extra run. A review reply carries summary, findings, cleared, extra, plan and caveats; a rewrite reply carries summary, code, changes, kept and caveats. The code below prints the gist of either: each confirmed finding and its fix, or each change.

KEY="react19-source-desk:$(jq -r .task input.json):$(shasum -a 256 input.json | cut -c1-16):a1"
JOB=$(curl -s -X POST "$BASE/run" -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \
  -H "Idempotency-Key: $KEY" --data @input.json | jq -r '.data.job_id')
while :; do
  J=$(api GET "/jobs/$JOB"); S=$(echo "$J" | jq -r '.data.status')
  case "$S" in succeeded|failed|cancelled) break;; esac; sleep 2
done
echo "$J" | jq -r '.data.output.output' > reply.json   # one JSON object, the reply contract
echo "$J" | jq '.data | {charged_credits, truncated}'
jq -r 'if .task == "rewrite" then (.changes[] | "\(.id): \(.change)") 
       else (.findings[] | "\(.id): \(.fix)") end' reply.json

import hashlib, time
key = "react19-source-desk:" + inp["task"] + ":" + hashlib.sha256(json.dumps(inp).encode()).hexdigest()[:16] + ":a1"
job = api("POST", "/run", inp, {"Idempotency-Key": key})
while True:
    j = api("GET", "/jobs/" + job["job_id"])
    if j["status"] in ("succeeded", "failed", "cancelled"):
        break
    time.sleep(2)
reply = json.loads(j["output"]["output"])  # the reply as one JSON object
print(j["charged_credits"], j.get("truncated"), reply["task"])
if reply["task"] == "rewrite":
    for x in reply["changes"]:
        print(x["id"], x["change"])
else:
    for x in reply["findings"]:
        print(x["id"], x["fix"])

import { createHash } from "node:crypto";
const key = `react19-source-desk:${input.task}:${createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 16)}:a1`;
const job = await api("POST", "/run", input, { "Idempotency-Key": key });
let j;
do { await new Promise((r) => setTimeout(r, 2000)); j = await api("GET", "/jobs/" + job.job_id); }
while (!["succeeded", "failed", "cancelled"].includes(j.status));
const reply = JSON.parse(j.output.output);
console.log(j.charged_credits, j.truncated, reply.task);
if (reply.task === "rewrite") { for (const x of reply.changes) console.log(x.id, x.change); }
else { for (const x of reply.findings) console.log(x.id, x.fix); }

sum := sha256.Sum256(raw) // add "crypto/sha256", "encoding/hex", "time" to the imports
key := "react19-source-desk:" + input["task"].(string) + ":" + hex.EncodeToString(sum[:8]) + ":a1"
job, _ := api("POST", "/run", input, map[string]string{"Idempotency-Key": key})
var j map[string]any
for {
	time.Sleep(2 * time.Second)
	j, _ = api("GET", "/jobs/"+job["job_id"].(string), nil, nil)
	if s := j["status"]; s == "succeeded" || s == "failed" || s == "cancelled" { break }
}
var reply map[string]any
json.Unmarshal([]byte(j["output"].(map[string]any)["output"].(string)), &reply)
fmt.Println(j["charged_credits"], j["truncated"], reply["task"])
key, b := "findings", "fix"
if reply["task"] == "rewrite" {
	key, b = "changes", "change"
}
xs, _ := reply[key].([]any)
for _, x := range xs {
	xx := x.(map[string]any)
	fmt.Println(xx["id"], xx[b])
}

var digest = java.security.MessageDigest.getInstance("SHA-256").digest(M.writeValueAsBytes(input));
String key = "react19-source-desk:" + input.get("task") + ":" + HexFormat.of().formatHex(digest, 0, 8) + ":a1";
JsonNode job = api("POST", "/run", input, Map.of("Idempotency-Key", key)), j;
do { Thread.sleep(2000); j = api("GET", "/jobs/" + job.get("job_id").asText(), null, null); }
while (!Set.of("succeeded", "failed", "cancelled").contains(j.get("status").asText()));
JsonNode reply = M.readTree(j.get("output").get("output").asText());
System.out.println(j.get("charged_credits") + " " + reply.path("task").asText());
if (reply.path("task").asText().equals("rewrite")) {
  for (JsonNode x : reply.path("changes")) System.out.println(x.path("id").asText() + " " + x.path("change").asText());
} else {
  for (JsonNode x : reply.path("findings")) System.out.println(x.path("id").asText() + " " + x.path("fix").asText());
}

require "digest"
key = "react19-source-desk:#{input["task"]}:#{Digest::SHA256.hexdigest(JSON.generate(input))[0, 16]}:a1"
job = api("POST", "/run", input, { "Idempotency-Key" => key })
j = nil
loop do
  sleep 2
  j = api("GET", "/jobs/#{job["job_id"]}")
  break if %w[succeeded failed cancelled].include?(j["status"])
end
reply = JSON.parse(j["output"]["output"])
puts [j["charged_credits"], j["truncated"], reply["task"]].inspect
if reply["task"] == "rewrite"
  reply["changes"].each { |x| puts "#{x["id"]} #{x["change"]}" }
else
  reply["findings"].each { |x| puts "#{x["id"]} #{x["fix"]}" }
end

$key = "react19-source-desk:" . $input["task"] . ":" . substr(hash("sha256", json_encode($input)), 0, 16) . ":a1";
$job = api("POST", "/run", $input, ["Idempotency-Key" => $key]);
do { sleep(2); $j = api("GET", "/jobs/" . $job["job_id"]); }
while (!in_array($j["status"], ["succeeded", "failed", "cancelled"]));
$reply = json_decode($j["output"]["output"], true);
echo $j["charged_credits"], " ", $reply["task"], "\n";
if ($reply["task"] === "rewrite") { foreach ($reply["changes"] as $x) echo $x["id"], " ", $x["change"], "\n"; }
else { foreach ($reply["findings"] as $x) echo $x["id"], " ", $x["fix"], "\n"; }

var digest = System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(input.ToJsonString()));
var key = $"react19-source-desk:{input["task"]}:{Convert.ToHexString(digest, 0, 8).ToLowerInvariant()}:a1";
var job = await Api.Call("POST", "/run", input, new() { ["Idempotency-Key"] = key });
JsonNode j;
do { await Task.Delay(2000); j = (await Api.Call("GET", "/jobs/" + job!["job_id"]))!; }
while (!new[] { "succeeded", "failed", "cancelled" }.Contains(j["status"]!.GetValue<string>()));
var reply = JsonNode.Parse(j["output"]!["output"]!.GetValue<string>())!;
var task = (string?)reply["task"];
Console.WriteLine($"{j["charged_credits"]} {task}");
if (task == "rewrite") { foreach (var x in reply["changes"]!.AsArray()) Console.WriteLine($"{x!["id"]} {x["change"]}"); }
else { foreach (var x in reply["findings"]!.AsArray()) Console.WriteLine($"{x!["id"]} {x["fix"]}"); }

Step 6 — POST /run-stream

The same run as Server-Sent Events, with the same input.json. Browsers receive progress ticks rather than text deltas; the final done event carries the reply.

# Server-Sent Events: tick/delta events while the job runs, then a final event with the job
curl -N -s -X POST "$BASE/run-stream" -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \
  -H "Idempotency-Key: react19-source-desk:$(jq -r .task input.json):$(shasum -a 256 input.json | cut -c1-16):a1" --data @input.json

rev = json.load(open("input.json"))  # the same run input as input.json: {"task": "review", "unit": "File: src/ui/kit.jsx\nKind: a shared component library file", "code": "import React, { forwardRef, useRef, useImperativeHandle } from \"react\";\n...", "carry": "", "facts": "The page's scan of 54 lines - 3 components ...\nFindings (id | area | severity | line | where | evidence | source | what the page did):\n- N1 | imports | minor | line 1 | ..."}
# - see the input table
req = urllib.request.Request(BASE + "/run-stream", method="POST", data=json.dumps(rev).encode(),
    headers={"Content-Type": "application/json", "Authorization": "Bearer " + TOKEN,
             "Idempotency-Key": "react19-source-desk:" + rev["task"] + ":" + hashlib.sha256(json.dumps(rev).encode()).hexdigest()[:16] + ":a1"})
with urllib.request.urlopen(req) as r:
    for line in r:
        line = line.decode().strip()
        if line.startswith("data:"):
            print(line[5:].strip()[:200])

const rev = JSON.parse(readFileSync("input.json", "utf8"));
const r = await fetch(BASE + "/run-stream", { method: "POST", body: JSON.stringify(rev), headers: {
  "Content-Type": "application/json", Authorization: "Bearer " + TOKEN,
  "Idempotency-Key": `react19-source-desk:${rev.task}:${createHash("sha256").update(JSON.stringify(rev)).digest("hex").slice(0, 16)}:a1` } });
const dec = new TextDecoder();
for await (const chunk of r.body) for (const line of dec.decode(chunk).split("\n"))
  if (line.startsWith("data:")) console.log(line.slice(5).trim().slice(0, 200));

rraw, _ := os.ReadFile("input.json") // add "bufio", "strings" to the imports
rs := sha256.Sum256(rraw)
req, _ := http.NewRequest("POST", base+"/run-stream", bytes.NewReader(rraw))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Idempotency-Key", "react19-source-desk:"+input["task"].(string)+":"+hex.EncodeToString(rs[:8])+":a1")
res, _ := http.DefaultClient.Do(req)
sc := bufio.NewScanner(res.Body)
for sc.Scan() { if l := sc.Text(); strings.HasPrefix(l, "data:") { fmt.Println(l[5:]) } }

String rev = java.nio.file.Files.readString(java.nio.file.Path.of("input.json"));
var rd = java.security.MessageDigest.getInstance("SHA-256").digest(rev.getBytes());
var sreq = HttpRequest.newBuilder(URI.create(BASE + "/run-stream")).header("Content-Type", "application/json")
  .header("Authorization", "Bearer " + token).header("Idempotency-Key", "react19-source-desk:" + input.get("task") + ":" + HexFormat.of().formatHex(rd, 0, 8) + ":a1")
  .POST(HttpRequest.BodyPublishers.ofString(rev)).build();
C.send(sreq, HttpResponse.BodyHandlers.ofLines()).body().filter(l -> l.startsWith("data:")).forEach(System.out::println);

rev = File.read("input.json")
uri = URI(BASE + "/run-stream")
req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json", "Authorization" => "Bearer #{TOKEN}",
  "Idempotency-Key" => "react19-source-desk:#{JSON.parse(rev)["task"]}:#{Digest::SHA256.hexdigest(rev)[0, 16]}:a1")
req.body = rev
Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |h|
  h.request(req) { |res| res.read_body { |chunk| chunk.each_line { |l| puts l if l.start_with?("data:") } } }
end

$rev = file_get_contents("input.json");
$ch = curl_init(BASE . "/run-stream");
curl_setopt_array($ch, [CURLOPT_POST => true, CURLOPT_POSTFIELDS => $rev, CURLOPT_HTTPHEADER => [
    "Content-Type: application/json", "Authorization: Bearer $TOKEN",
    "Idempotency-Key: react19-source-desk:" . json_decode($rev, true)["task"] . ":" . substr(hash("sha256", $rev), 0, 16) . ":a1"],
    CURLOPT_WRITEFUNCTION => function ($ch, $chunk) { foreach (explode("\n", $chunk) as $l) if (str_starts_with($l, "data:")) echo $l, "\n"; return strlen($chunk); }]);
curl_exec($ch);

var rev = File.ReadAllText("input.json");
var rd = System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(rev));
var sreq = new HttpRequestMessage(HttpMethod.Post, Api.Base + "/run-stream") { Content = new StringContent(rev, System.Text.Encoding.UTF8, "application/json") };
sreq.Headers.Add("Authorization", "Bearer " + Api.Token);
sreq.Headers.Add("Idempotency-Key", $"react19-source-desk:{input["task"]}:{Convert.ToHexString(rd, 0, 8).ToLowerInvariant()}:a1");
using var http = new HttpClient();
using var res = await http.SendAsync(sreq, HttpCompletionOption.ResponseHeadersRead);
using var rdr = new StreamReader(await res.Content.ReadAsStreamAsync());
for (string? l; (l = await rdr.ReadLineAsync()) != null;) if (l.StartsWith("data:")) Console.WriteLine(l);