Skip to content

feat(fsdev): fsdev dev --watch, and an app's pages from source through Vite (FIX-1770 PR-B) - #2740

Merged
jhoffner merged 3 commits into
mainfrom
claude/project-thread-ibr67c
Oct 6, 2026
Merged

jhoffner merged 3 commits into
mainfrom
claude/project-thread-ibr67c

Conversation

@jhoffner

@jhoffner jhoffner commented Oct 4, 2026 •

Copy link
Copy Markdown
Collaborator

When you edit a Lab's flows while fsdev dev is open, you must stop and start the process after each change. A page served from an app's source also needs a second terminal and a proxy.

What this does

fsdev dev --watch restarts the server on the same port when you save a file that the config loaded, a file in the config's folder, or an .env.local file that fsdev loaded. It also restarts when a file is added to the config's folder. An open page then reloads. It does not restart for a page, data or node_modules file. When a restart fails, the command waits for the next save. It binds loopback only. With --app, a package that exports getSourceRoot() is served from source through its own Vite, on the same port.

<img src="https://raw.githubusercontent.com/fixpoint-labs/flow-state-dev/3ff093af9f79fdecd29808f281da74d21bd09824/specs/issues/FIX-1770/figures/what-changes.svg"· width="940" alt="Before: two terminals and a lab script, checkout only. After: one installed command over fsdev's app hook and node's serve()" />

This PR adds the --watch half of the picture. PR-C adds the Shift Manager half.

What's asked of you

@flow-state-dev/node gets a third page option, pageScript

  • D1 said that node gets only two generic page options. Without a third, a built page cannot reload by itself after a restart. The reload was added to the spec in round 1. pageScript writes an inline script into each HTML page, on any host. It contains nothing about dev tools.
  • Recommendation: keep it. If this is wrong, node has one more additive public option. Before 1.0, a minor release can remove it.

The other decisions follow the approved spec.

Parts worth reviewing closely

For the code reviewer:

  1. packages/cli/src/dev-watch.ts and dev-watch-preload.ts. A child sends its config folder's files to node --watch as {"watch:require": [...]}. A preload removes node_modules paths from the reports that Node sends. Node does not document this IPC message. Is it acceptable to depend on it? If Node changes it, V5 fails. Nothing fails silently.
  2. startListeners in commands/dev.ts. The listen and teardown block moved here, as the PR-A review asked. Check that teardown order and disposeOnClose are the same as in PR-A.

Part of FIX-1770, PR 2 of 3 (the order is in D3) · spec: specs/issues/FIX-1770/ on main, reviewed in #2734 · PR-A: #2735 (merged) · goal check: runs in PR-C · this PR merges into main.

How to review this: altitude, what's in scope, what's deliberately unsettled

How to review this. This implements an approved spec — the approach and the numbered
decisions in its DECISIONS.md are already signed off by a human, so please review the
code against that direction, not the direction itself. The canonical set is retained
at specs/issues/<ISSUE-ID>/ on main; Linear links to it and the original merged spec
PR, which keeps review history. Follow-up amendment PRs explain later direction changes.
Current architecture docs remain the authority for shipped behavior (BP-037).

Most valuable here: correctness on the second path (the legacy shape, the null
boundary, the concurrent case, the cancel path), anything deriving an auth or routing
decision from caller-controllable input, and a behaviour the tests assert around
rather than on.

Already settled upstream: the approach and every decision in the spec's DECISIONS.md
(human-approved — if one is wrong, say so as a spec finding and it gets folded back; don't
re-argue it inline), and the conventions in docs/contributing/best-practices.md.

Engineering calls: decided along the way, no product sign-off needed
  • The parent re-runs process.argv[1] with the same arguments. A wrapper command (PR-C's shift-manager) therefore restarts as itself and keeps its own options, for example the page meta. If this is wrong, PR-C must give the child its own entry.
  • The parent fixes the DevTool's port too, not only the app's port. Thus an open DevTool tab also stays on one address across restarts. If this is wrong, a DevTool tab breaks on each restart.
  • Config-folder files are sent before the config loads. A WORKER.md that the config reads at import, and that breaks the load, then restarts the Lab when you fix it. If this is wrong, a broken tree file stops --watch until you save a module.
  • The page script opens its stream again after an error. It does not depend on the browser's own retry. A Node EventSource stopped after one refused connection. If this is wrong, a page can stay open on a dead server.
  • Vite resolves only from the app's own node_modules chain, not through require.resolve. A pnpm bin shim puts its store on NODE_PATH, and in a test that found a Vite near fsdev. If this is wrong, an app with no Vite gets one that it did not install.
  • A watch child drains in 1 s (shutdownGraceMs), and it ends its reload streams first. An open flow stream thus does not delay a restart by 10 s. If this is wrong, an in-flight request stops sooner during a restart.
  • A file added to the config's folder restarts the watcher. node --watch only knows files that it was told about. The child therefore watches the folders it walked, and when an eligible file appears, it asks the parent to start node --watch over on the same ports. If this is wrong, a new worker's WORKER.md needs a save to some other file first.
  • A missing --config or --dotenv file fails in the parent. A child that fails before it reports anything leaves node --watch with nothing to restart on.
  • The report gate was removed. First, the preload also stopped reports after the Lab loaded, to block Vite's temporary config bundle. Vite writes that bundle under node_modules/.vite-temp, so the node_modules rule already covers it. A real Vite child in V5 proves this: it has no restart loop.
Everything else: verification with red states, docs, files

Checks. Typecheck passes for @flow-state-dev/fsdev and @flow-state-dev/node (turbo, with dependencies). validate-package-boundaries passes. The full fsdev and node vitest suites pass on the rebased head.

V5, BR-15–BR-19, on a real child (packages/cli/test/dev-watch.test.ts). The test runs node --import tsx src/bin.ts dev --watch --port 0 in a temporary Lab and saves real files. A new boot id meta counts as a restart.

Case Green Red state
Save an imported module: restart on the same port, the change is served pass on PR-A's head: error: unknown option '--watch'. With the child picking its own port (mutation M7): no restart within 30000ms
Save a config-folder file that no module imports (WORKER.md) pass tree files not sent (M2): no restart within 30000ms
Save a page file, a data file, a dot-folder file, or a node_modules module that the Lab imported: no restart pass M3, M4, M5 or M1 removes that skip: expected [ …(3) ] to deeply equal [ Array(1) ]
Save an .env.local file that fsdev loaded pass on 83c48a7: no restart within 30000ms
Create tree/b/WORKER.md after start: restart, then its next save restarts again pass on 83c48a7: no restart within 30000ms
Create a new data file, a file in a dot folder, or a page file: no restart pass without the data-file filter in the folder watcher: data case fails
--watch with a missing --config or --dotenv: exit 3 with the config error pass on 83c48a7: expected 'still running' to be 3
A failed restart keeps watching, and the next save starts it pass (characterization of node --watch)
A tree file breaks the load at import, then its fix restarts the Lab pass with files sent after the load, as first written: no restart within 30000ms
An open built page reloads by itself after a failed child, on the same origin (the page's own served script, real EventSource, separate process) pass the page script without its own reconnect (M6): expected 'timeout' to be +0
SIGTERM stops the watcher and its child, and nothing stays on the port pass (teardown guard)
An app from source through Vite: no restart loop over 4 s, a page-source save does not restart, a Lab save does pass (guards the spec's Vite temp-bundle risk)

In Chromium (headless shell 147, run locally, not in CI): the page reloaded by itself after a module save, on one origin. {"boot1":"f1df70d8…","boot2":"f4a0e26f…","navigations":["http://localhost:45857/","http://localhost:45857/"],"body":"built page"}. With a fake xdg-open, the browser opened once across three children.

V6, BR-21 and BR-22 (packages/cli/test/dev-app.test.ts, run as a watch child):

Case Red state on PR-A's head
The index carries /@vite/client, fsdev-devtool-url, the bearer config and the boot meta. A client route gets the same index. A module comes through Vite. The HMR socket opens on the same port expected '…ops…' to contain 'from source'
No Vite in the app's install: the command says so and serves the built pages expected '…' to contain 'Vite doesn't resolve from'. This test also failed against the first require.resolve version, which found vitest's Vite on NODE_PATH
getSourceRoot() returns nothing, or there is no --watch: built pages (off states, BP-035)
--watch with a non-loopback host: refused, exit 3 (BR-15) expected undefined to be an instance of CliError

V4 (layer line). dev-vite.ts, dev-watch.ts and dev-watch-preload.ts are added to the scan. 9 of 9 pass.

node. pageScript tests (red before: expected '…<head></head>…' to contain '<script>1;</script></head>'). Two characterization tests show that runPageHandler holds a streaming response open and survives a client that drops the stream. Both passed on PR-A's code. They pin the behaviour that the reload stream and Vite depend on.

Docs. apps/docs/docs/api/cli.md gets the --watch row, a "Restarting as you edit" subsection, and the getSourceRoot() paragraph from DOCS.md. packages/cli/README.md gets the flag and an example. packages/node/README.md gets the pageScript row. Changesets: patch for @flow-state-dev/fsdev and @flow-state-dev/node.

Files. New: packages/cli/src/dev-watch.ts (supervisor, files sent from the config folder, reload signal), dev-watch-preload.ts (removes node_modules reports), dev-vite.ts (Vite middleware pages). Changed: commands/dev.ts (now reads as parse options → resolve runtime → start listeners), dev-app.ts (resolveApp, getSourceRoot(), Vite lookup), load-config.ts (exports locateConfig), node/src/page-html.ts and serve.ts (pageScript).

🤖 Generated with Claude Code

https://claude.ai/code/session_018KBgKPRLfqjmV2LS88Eg9S


Note

Medium Risk
Substantial dev-server orchestration relies on undocumented node --watch IPC and child process supervision; impact is limited to loopback local dev, but regressions could break the primary edit-reload workflow.

Overview
Adds fsdev dev --watch (loopback only): a parent supervises the same CLI entry under node --watch, keeps ports fixed across restarts, restarts when config-loaded modules, files under the config directory, or loaded .env files change, and auto-reloads open pages via boot-id meta, an SSE endpoint, and injected pageScript. Failed starts wait for the next save; invalid --config / --dotenv fail in the parent before spawning.

With --app, packages exporting getSourceRoot() can be served from source through the app’s own Vite (middleware on the same origin as /api/flows); otherwise built assets are used. New CLI modules implement watching (dev-watch, preload filter for node_modules reports), Vite integration (dev-vite), and resolveApp in dev-app. executeDevCommand splits into runtime resolution and startListeners teardown.

@flow-state-dev/node gains pageScript on serve() / createPageHtmlTransform (inline script after meta tags, with </ escaping). Docs, changesets, and integration tests cover watch behavior and Vite fallback paths.

Reviewed by Cursor Bugbot for commit 0a9b4ef. Configure here.

…h Vite (FIX-1770 PR-B)

fsdev dev --watch re-runs its own entry as a child under node --watch, the
one watch authority. The parent fixes the ports once (--port 0 included),
opens the browser when the first child is up, and keeps running when a child
fails. A child reports its config folder's files to node --watch before the
config loads, and a preload drops every node_modules path, so a Lab change
restarts it and a page, data or dependency file does not. Each child stamps
its pages with a boot id meta and serves a stream the page script reconnects
to, so an open page, built ones included, reloads when the next child is up.
Loopback only.

Under --watch, an --app package that also exports getSourceRoot() is served
from that folder through the Vite its own install resolves, in middleware
mode on the same port, its index through the same page transform as built
pages; otherwise the built pages are served, and the command says why.

@flow-state-dev/node serve() and createPageHtmlTransform gain pageScript, an
inline script written after the page meta. executeDevCommand now reads as
parse options, resolve the runtime, start the listeners.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018KBgKPRLfqjmV2LS88Eg9S
@vercel

vercel Bot commented Oct 4, 2026 •

Copy link
Copy Markdown

The latest updates on your projects. Learn more about Vercel for GitHub.

3 Skipped Deployments
Project Deployment Actions Updated
flow-state-dev-docs Ignored Ignored Oct 4, 2026 11:29pm UTC
flow-state-dev-kitchen-sink Ignored Ignored Oct 4, 2026 11:29pm UTC
flow-state-dev-ui Ignored Ignored Preview Oct 4, 2026 11:29pm UTC

Request Review

@linear-code

linear-code Bot commented Oct 4, 2026

Copy link
Copy Markdown

FIX-1770

@chatgpt-codex-connector

chatgpt-codex-connector Bot commented Oct 4, 2026 •

Copy link
Copy Markdown

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review Status Commit Review trigger
📝 Code Review ✅ Completed 2026-10-04T22:10:00.442239Z 83c48a7 PR opened
ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

@cursor

cursor Bot commented Oct 4, 2026

Copy link
Copy Markdown
Contributor

Bugbot couldn't run - usage limit reached

Bugbot is counted against Cursor usage for this user or team, and this run hit a usage or spend limit.

A user or team admin can review and increase usage limits in the Cursor dashboard.

(requestId: 20e5ce15-f6f9-48ea-be2c-9b706b3c3442)

jhoffner commented Oct 4, 2026

Copy link
Copy Markdown
Collaborator Author

Second look + architecture pass (read-only, from the diff at 83c48a7; I did not run the suites)

Overall the approach holds up. The node --watch supervisor with a child re-running process.argv[1] is the leaner shape. The alternative would be an in-process module-graph watcher, and that is more code and more wrong. The findings below are ordered by how much I'd act on them.

1. reportLabFiles is a denylist over the whole config dir, and that can restart-loop (should fix)

dev-watch.ts reportLabFiles walks every file under the config's folder and skips only dot entries, node_modules, .sqlite/.db* and the app's pages.

  • A Lab that writes anything else under its config dir restarts itself on each write. Examples: .json/.log/.md artifacts, memory or scratch files, dist/, coverage/, logs/, generated output. The sqlite regex shows the author already hit this once, but the fix doesn't generalize.
  • When the config sits at a package or repo root, the walk sends thousands of paths in one IPC message and gives node --watch thousands of watchers. That is an inotify-limit risk on Linux and a slow first boot.
  • BR-16 only covers "page, data, dot-folder, node_modules". It doesn't cover Lab-written files.

Suggestion: invert it to an allowlist of source and tree extensions (.ts/.tsx/.js/.mjs/.cjs/.json?/.md only for WORKER.md-style tree files), or honor .gitignore, and cap the file count with a printed note when exceeded. Add a test where the Lab writes a .json under its own dir and no restart follows (the BP-035 "off state"). This is the one finding I'd treat as blocking-ish.

2. The parent does the child's work twice (moderate)

In executeDevCommand, resolveApp(...) runs in both the supervisor parent and the child. For --app <package> that means importAppPackage executes the app package's module code in the parent, and again in each child.

  • The parent only needs "fail early on bad input".
  • It also runs resolveDevToolAssets() just to decide whether to reserve a DevTool port, which duplicates the child's own check in startListeners.

Suggestion: have the parent resolve only what it needs. A cheap existence check on the app is enough, or put the DevTool-port decision in one helper that both sides call. It is cheap to do now and avoids a divergence later: if the two checks disagree, the child gets a DevTool port the parent never reserved, or the reverse.

3. executeDevCommand now has two modes in one body (structural, worth doing in this PR since it already carved out startListeners)

The function branches parent / child / plain via options.watch === true && watchChild === undefined and watchChild !== undefined, with the guards interleaved. The startListeners extraction (the PR-A review ask) is good, and teardown order and disposeOnClose match PR-A.

Suggestion: pull the parent branch into one superviseDevCommand(options). Then executeDevCommand reads as "validate, then either supervise or serve", and the loopback guard sits in one place. Don't add more abstraction than that.

4. reservePort then release then child rebinds is a TOCTOU window (minor, acceptable)

Another process can take the port between the parent's probe and the child's bind. In dev this is rare, and the failure is loud (EADDRINUSE in the child, and node --watch waits for a save). Just say so in the reservePort doc comment so the next reader doesn't "fix" it.

5. Undocumented watch:require IPC (the PR's question 1)

Acceptable, given V5 fails loudly if Node changes it. Two cheap hardening asks:

  • Have the preload no-op and warn once if process.send is present but the first watch:require message never arrives within N seconds. Today a Node change would silently degrade to "restarts on nothing".
  • Pin the minimum Node version in the test's skip/guard so a CI Node bump surfaces here first.

The preload also monkey-patches the global process.send for the child's whole life. It's confined to --watch children, so I'm fine with it, but it is the single most fragile line in the PR.

6. pageScript on @flow-state-dev/node (the PR's sign-off ask)

I agree with keeping it, because the built-page reload needs it on any host. One design note for later, not this PR: pageMeta, pageScript and devtoolConfig are now three options that all mean "write something into <head>". If a fourth appears, collapse them into one pageHead hook rather than growing the option list. Also, the escape only handles </, which is enough for the fsdev-authored script, but the doc says "any script". Either say "must not contain <!--" or escape it too.

7. Smaller things

  • watchOptions is spread into the DevTool server, which also gets the same reload.handler. Fine, but both servers share one streams set, so reload.close() ending streams for both is intended. A one-line comment would save the next reader a trace.
  • ready.catch(() => {}) in dev-vite.ts swallows the rejection for the unhandled-rejection case. attach rethrows to the caller, so the real error surfaces. OK, but the comment should say which path reports it.
  • resolveViteEntry re-implements a tiny exports resolver. It is justified by the NODE_PATH finding. Leave it, but add the exports-as-array case (or a comment that it's unsupported), since Vite could ship one.

Not recommending

No broader refactor of dev.ts (still ~690 lines) beyond item 3. The rest of the file isn't this PR's to touch (CLAUDE.md §3).


Generated by Claude Code

@cursor cursor Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Simplify review (FIX-1770 PR-B)

Verdict: approve. The feature set (stable port across restarts, Lab-only triggers, built-page reload, optional app source on the same origin as /api/flows) forces more moving parts than a plain fsdev dev, but the split here is mostly the minimum honest design—not accidental sprawl.

Did the approach go too far?

I looked for a materially smaller design that still hits the spec (BR-19–22 in FIX-1770):

Alternative Why it doesn’t really simplify
Chokidar/nodemon instead of node --watch Adds a dependency and reimplements restart orchestration; you’d still need the parent for fixed ports, the preload filter, reportLabFiles, and the reload channel for built HTML.
Spawn vite CLI on another port + proxy Two origins (or a proxy layer), harder DevTool meta / API same-origin story, more process supervision. Vite middleware mode on the existing serve() server is the usual integrated pattern—and you already use it in a thin ~100-line module.
Defer Vite to “run vite yourself” Smaller PR, but pushes integration cost to every app author and fights the --app + one URL goal from PR-A.
LiveReload/BrowserSync for reload Another dependency; still wouldn’t cover “new child, same port, built static tree” without custom boot-id semantics you already encoded once.

What would have been simpler product scope: ship --watch without source/Vite first, then add getSourceRoot() in a follow-up. That’s a sequencing tradeoff, not evidence this implementation is over-engineered for the combined scope.

What looks clean

  • Module boundaries: dev-watch-preload must stay isolated for --import; dev-watch / dev-vite / dev-app responsibilities are clear; serve()/page-html extensions from PR-A are reused instead of duplicating HTML injection in the CLI.
  • Platform primitive: node --watch + IPC watch:require / filtered watch:import is the right “established” choice versus a home-grown watcher for server restart.
  • Tests: Real child-process coverage (including Vite and reload EventSource) matches the risk; ~45s in that file is acceptable for what it pins.

Optional follow-ups (non-blocking)

See inline notes on resolveViteEntry (Node resolution vs hand-parsed exports) and reportLabFiles (sync tree walk at child boot—fine today; revisit if config trees get huge).

Checks: pnpm --filter @flow-state-dev/fsdev test — 334 passed (including dev-watch.test.ts).

No changeset concern from this review; fragments already present.

Open in Web View Automation 

Sent by Cursor Automation: Review For Best Approach

Comment thread packages/cli/src/dev-app.ts Resolved
Comment thread packages/cli/src/dev-watch.ts Resolved
Comment thread packages/cli/src/dev-watch.ts Resolved

@cursor cursor Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code Snob — already tight (83c48a714). No POC.

I read packages/cli/src/dev-watch.ts, dev-watch-preload.ts, dev-vite.ts, dev-app.ts, commands/dev.ts, packages/node/src/page-html.ts, serve.ts, and the new cases in packages/cli/test/dev-watch.test.ts, dev-app.test.ts, and packages/node/test/serve.test.ts.

A rewrite would not shrink this contract.

  • The preload imports nothing, so it cannot share the config-folder walk. The walk skips node_modules so it does not send that tree; the preload drops paths Node already reported. Different reports.
  • chainPageHandlers is the one composition: the DevTool server gets the reload handler alone, the app chains Vite after it. Inlining deletes the function and leaves both call sites.
  • createVitePages waits because the handler is registered before attach. A waiter list is the same length, and the failure path gets worse.
  • resolveViteEntry walks the app's node_modules and picks the import export. require.resolve is shorter and selects the require condition. That is the recorded NODE_PATH fix.
  • callExport is already the shared getAssetPath / getSourceRoot call. startListeners is the split PR-A asked for. The two serve() calls still differ on staticDir, page meta (the DevTool URL), disposeOnClose, and the Vite chain.
  • The parent's IPv6 bracket and urlHost are one expression. Sharing them adds an import.
  • The two stream tests pin different failures (the handler holds the body, the client drops it). pageScript's staticDir matches the per-describe fixture already in that file.

The module headers restate the files. Deleting them does not shrink the contract. I did not reopen pageScript, the node --watch IPC, re-running process.argv[1], the fixed DevTool port, reporting files before the config loads, the script's own reconnect, or the 1s drain. Those are already recorded.

Open in Web View Automation 

Sent by Cursor Automation: Code Snob

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 83c48a7143

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Comment thread packages/cli/src/commands/dev.ts Resolved
Comment thread packages/cli/src/dev-watch.ts Resolved
Comment thread packages/cli/src/dev-watch.ts Resolved
claude added 2 commits October 4, 2026 22:20
…cal and new files (FIX-1770 PR-B)

- A missing --config or --dotenv file now fails in the parent with the
  config error. Before, the child failed before it reported a file, and
  node --watch waited with nothing to restart it on.
- A watch child reports the .env.local files fsdev loaded, so a save to
  one restarts it.
- A file created under the config's folder after a child started asks
  the parent to start the watcher over on the same ports, since
  node --watch only knows the files it was told about.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018KBgKPRLfqjmV2LS88Eg9S
…es (FIX-1770 PR-B)

node --watch can drop a SIGTERM that lands while it is restarting its
child. Before this fix, a file created during a save left the supervisor
waiting on a watcher that never exited, and every later new file was
ignored. The supervisor now sends SIGTERM again until the watcher exits.
A directory is also watched before it is read, so a file created between
the two is still seen.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018KBgKPRLfqjmV2LS88Eg9S
@cursor

cursor Bot commented Oct 4, 2026

Copy link
Copy Markdown
Contributor

Bugbot couldn't run - usage limit reached

Bugbot is counted against Cursor usage for this user or team, and this run hit a usage or spend limit.

A user or team admin can review and increase usage limits in the Cursor dashboard.

(requestId: 62fb52f5-75f5-425a-aa14-e1d4fcfa4425)

@jhoffner
jhoffner added this pull request to stack #2779 October 5, 2026 23:40
@jhoffner
jhoffner merged commit 74f9a4f into main Oct 6, 2026
14 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants