fix(desktop): harden core barrel against node-only value exports

[sunheyi6]

Summary

Defensive hardening of the renderer-facing @maka/core barrel: the browser-consumed barrel no longer value-exports any module whose implementation depends on node:*, and an executable regression guard prevents the Node-only export graph from returning to the renderer entry path.

Scope (per review 4bd7b29a, re-scoped from "fix" to defensive hardening — the white-screen mechanism was not reproducible under the pinned Vite 8.1.5 toolchain, where tree-shaking removes the node:* references and dev-mode proxies throw only on call, not on import):

• packages/core/src/index.ts — drop value exports for tool-ledger-scanner (node:util), tool-args-identity (node:crypto), canonical-runtime-event (node:util), and tool-recovery-bundle (node:crypto); keep only type exports in the barrel. The explicit subpaths (@maka/core/tool-args-identity, @maka/core/tool-ledger-scanner, @maka/core/canonical-runtime-event, @maka/core/tool-recovery-bundle, @maka/core/runtime-boundary) already exist in package.json exports and now carry the value consumers (runtime, storage, runtime-host).
• apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts (+ fixtures) — re-lands the regression guard in executable form against the built barrel artifact the renderer actually consumes: a child Node process registers a loader hook that throws on every node:* import and then imports @maka/core; it exits non-zero the moment the barrel graph evaluates Node-only code. This replaces the source-regex contract pruned by chore: prune source-regex tests and parallelize the e2e suite #1727.

Why defensive

Under the pinned toolchain the production renderer bundle tree-shakes the node:* references and dev mode never calls the proxied functions, so there is no current white screen — but the invariant ("importing @maka/core in a browser-like environment evaluates no node:* module") relied on tree-shaking luck rather than construction. Keeping Node-only values behind explicit subpaths makes the boundary structural and test-enforced.

Validation

• npm test (full suite: clean + build:test + script tests + all workspace test:dist)
• new regression guard passes: importing built @maka/core evaluates no node:* module
• Biome check and git diff --check

[Astro-Han]

Reviewed the current head. Moving runtime-boundary values to the existing subpath fixes the renderer import boundary without adding a second implementation. The renderer build and CI coverage are appropriate. No findings.

The branch currently conflicts with main, so the resolved head will need another review.

[Astro-Han]

Review findings (independent deepseek-v4-flash review, 2 passes)

The fix itself (moving runtime-boundary value exports out of the core barrel) is correct and mechanically complete — but the earlier approval no longer covers the head (the merge commits changed the branch), and two P2s need a decision.

P2 — the startup contract test you added was swallowed by the merge; the head has no regression guard

startup-loading-shell-contract.test.ts (3 tests added in 6da3471be, including the barrel-purity assertion) was deleted on main by #1727 and the merge commit fc099b75 kept main's deletion — git ls-tree 4bd7b29a has no such file. The PR body's "startup loading shell contract: 3 passed" verification is therefore not reproducible on the current head, and the exact #1573 regression class this PR fixes can silently return. Please re-land the contract in an executable form (e.g. assert the renderer build output contains no node: imports rather than a source-regex test), or explicitly defer with a reason.

P2 — the barrel still value-exports 3 other Node-only modules; the new comment overstates the invariant

packages/core/src/index.ts:255-260 (tool-ledger-scanner → node:util), :291 (tool-args-identity → node:crypto), :292-295 (canonical-runtime-event → node:util), and :285-290 (tool-recovery-bundle → node:crypto) are still value-exports, while :304-306 claims "renderer imports of @maka/core do not evaluate Node-only modules". Today the renderer graph happens to tree-shake them (verified: 0 node: references in the production bundle; dev-mode Vite uses a browser-external proxy that only throws on call, not on import), so there is no current white screen — but the fix relies on luck, not construction. Either move the remaining Node-only value exports behind subpaths (the subpaths already exist in package.json exports), or correct the comment to state the actual invariant.

Needs discussion — the root-cause mechanism is not reproducible with the pinned toolchain

We rebuilt the PR base (barrel with runtime-boundary value export), the head, and the fix-parent state with the pinned Vite 8.1.5: the production renderer build succeeds in all three states with zero node: references (tree-shaken), and dev mode does not throw on module evaluation (the proxy throws only when a function is called; the renderer never calls them). Current main re-added all four value exports and the renderer still works. If the mechanism is "barrel evaluation of node:crypto throws before createRoot", it doesn't hold under the pinned toolchain — the white screen you observed may have a different root cause, and this PR may be defensive hardening rather than the fix. Please reproduce the original white screen on a clean environment with the pinned toolchain (with bundle evidence), or re-scope the PR as defensive hardening.

Gate: no P0/P1 → not a FAIL; the two P2s need to be handled (fix or explicit deferral) before merge.

[sunheyi6]

Merged latest main (incl. upstream 13cf3e6) into the branch and resolved all conflicts — the PR is now mergeable.

Conflict resolution notes:

• packages/core/src/index.ts: kept this PR's hardening (Node-only value exports stay type-only/absent in the barrel) against main re-adding them
• packages/storage/src/agent-run-store.ts: kept both the PR's subpath imports (canonical-runtime-event, tool-ledger-scanner) and main's new orchestration imports
• execution-stores.test.ts: deleted upstream (refactor(storage): make SQLite the sole operational authority #1994) — the PR's import migration on it is moot, deletion kept
• New consumers main/upstream introduced for the removed barrel values were migrated to subpaths: ai-sdk-backend.ts (stripUndefinedDeep → @maka/core/tool-args-identity), runtime-host execution-host tests (canonicalToolArgsHash → subpath), conversation-copy test (canonicalToolArgsHash → subpath, workspace store import per upstream)

The two P2s from the review are addressed on the head:

• P2 regression guard: re-landed in executable form — apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts spawns a child Node process with a loader hook that throws on any node:* import, then imports the built@maka/core barrel; passes locally (1/1)
• P2 remaining Node-only value exports: tool-ledger-scanner, tool-args-identity, canonical-runtime-event, tool-recovery-bundle are now type-only (or absent) in the barrel; value consumers route through the existing subpaths

Local validation: full build:test clean, core suite 772/772, ai-sdk-backend 175/175, barrel regression guard passes, biome lint clean. (Storage/runtime-host sqlite & git-marker tests fail on this Windows box due to temp-dir junction/EBUSY lock issues — pre-existing environment noise, unaffected by this PR.)

[Astro-Han]

Thanks — the revised direction looks sound. Moving Node-only value exports behind the existing subpaths keeps the renderer-facing @maka/core root browser-safe without introducing a parallel implementation, and the built-artifact loader guard is the right level of protection.

The earlier review concerns appear resolved. The remaining work is mainly integration with current main:

P2 — Please rebase and preserve the browser-safe root invariant while resolving conflicts

This branch now conflicts with main, which has since added or restored more root-barrel values and consumers, including Node-dependent paths. A mechanical conflict resolution could either reintroduce the renderer boundary problem or remove exports that current consumers need.

Please rebase onto the latest main, move any newly exposed Node-only values to their existing subpaths as needed, and make sure the built-artifact guard still passes on the resulting tree.

P3 — The test comments overstate the reproduced failure mechanism

The comments currently say that Vite imports of node:* fail before createRoot() and that the loader hook mirrors the renderer. The PR description now correctly treats this as defensive hardening rather than a confirmed reproduction of the original white-screen mechanism.

It would be more accurate to describe the test as intentionally enforcing a stronger structural invariant: the renderer-facing root barrel must remain loadable without Node built-ins, regardless of current tree-shaking behavior.

The unused FIXTURES_DIR constant can also be removed while touching the test.

The implementation itself does not need another redesign. After the rebase and a fresh CI run, this should be ready for another quick review. Thanks!

[sunheyi6]

Summary

Defensive hardening of the renderer-facing @maka/core barrel: the browser-consumed barrel no longer value-exports any module whose implementation depends on node:*, and an executable regression guard prevents the Node-only export graph from returning to the renderer entry path.

Scope (per review 4bd7b29a, re-scoped from "fix" to defensive hardening — the white-screen mechanism was not reproducible under the pinned Vite 8.1.5 toolchain, where tree-shaking removes the node:* references and dev-mode proxies throw only on call, not on import):

• packages/core/src/index.ts — drop value exports for tool-ledger-scanner (node:util), tool-args-identity (node:crypto), canonical-runtime-event (node:util), and tool-recovery-bundle (node:crypto); keep only type exports in the barrel. The explicit subpaths (@maka/core/tool-args-identity, @maka/core/tool-ledger-scanner, @maka/core/canonical-runtime-event, @maka/core/tool-recovery-bundle, @maka/core/runtime-boundary) already exist in package.json exports and now carry the value consumers (runtime, storage, runtime-host).
• apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts (+ fixtures) — re-lands the regression guard in executable form against the built barrel artifact the renderer actually consumes: a child Node process registers a loader hook that throws on every node:* import and then imports @maka/core; it exits non-zero the moment the barrel graph evaluates Node-only code. This replaces the source-regex contract pruned by chore: prune source-regex tests and parallelize the e2e suite #1727.

Why defensive

Under the pinned toolchain the production renderer bundle tree-shakes the node:* references and dev mode never calls the proxied functions, so there is no current white screen — but the invariant ("importing @maka/core in a browser-like environment evaluates no node:* module") relied on tree-shaking luck rather than construction. Keeping Node-only values behind explicit subpaths makes the boundary structural and test-enforced.

Validation

• npm test (full suite: clean + build:test + script tests + all workspace test:dist)
• new regression guard passes: importing built @maka/core evaluates no node:* module
• Biome check and git diff --check

[Astro-Han]

Reviewed the current head. Moving runtime-boundary values to the existing subpath fixes the renderer import boundary without adding a second implementation. The renderer build and CI coverage are appropriate. No findings.

The branch currently conflicts with main, so the resolved head will need another review.

[Astro-Han]

Review findings (independent deepseek-v4-flash review, 2 passes)

The fix itself (moving runtime-boundary value exports out of the core barrel) is correct and mechanically complete — but the earlier approval no longer covers the head (the merge commits changed the branch), and two P2s need a decision.

P2 — the startup contract test you added was swallowed by the merge; the head has no regression guard

startup-loading-shell-contract.test.ts (3 tests added in 6da3471be, including the barrel-purity assertion) was deleted on main by #1727 and the merge commit fc099b75 kept main's deletion — git ls-tree 4bd7b29a has no such file. The PR body's "startup loading shell contract: 3 passed" verification is therefore not reproducible on the current head, and the exact #1573 regression class this PR fixes can silently return. Please re-land the contract in an executable form (e.g. assert the renderer build output contains no node: imports rather than a source-regex test), or explicitly defer with a reason.

P2 — the barrel still value-exports 3 other Node-only modules; the new comment overstates the invariant

packages/core/src/index.ts:255-260 (tool-ledger-scanner → node:util), :291 (tool-args-identity → node:crypto), :292-295 (canonical-runtime-event → node:util), and :285-290 (tool-recovery-bundle → node:crypto) are still value-exports, while :304-306 claims "renderer imports of @maka/core do not evaluate Node-only modules". Today the renderer graph happens to tree-shake them (verified: 0 node: references in the production bundle; dev-mode Vite uses a browser-external proxy that only throws on call, not on import), so there is no current white screen — but the fix relies on luck, not construction. Either move the remaining Node-only value exports behind subpaths (the subpaths already exist in package.json exports), or correct the comment to state the actual invariant.

Needs discussion — the root-cause mechanism is not reproducible with the pinned toolchain

We rebuilt the PR base (barrel with runtime-boundary value export), the head, and the fix-parent state with the pinned Vite 8.1.5: the production renderer build succeeds in all three states with zero node: references (tree-shaken), and dev mode does not throw on module evaluation (the proxy throws only when a function is called; the renderer never calls them). Current main re-added all four value exports and the renderer still works. If the mechanism is "barrel evaluation of node:crypto throws before createRoot", it doesn't hold under the pinned toolchain — the white screen you observed may have a different root cause, and this PR may be defensive hardening rather than the fix. Please reproduce the original white screen on a clean environment with the pinned toolchain (with bundle evidence), or re-scope the PR as defensive hardening.

Gate: no P0/P1 → not a FAIL; the two P2s need to be handled (fix or explicit deferral) before merge.

[sunheyi6]

Merged latest main (incl. upstream 13cf3e6) into the branch and resolved all conflicts — the PR is now mergeable.

Conflict resolution notes:

• packages/core/src/index.ts: kept this PR's hardening (Node-only value exports stay type-only/absent in the barrel) against main re-adding them
• packages/storage/src/agent-run-store.ts: kept both the PR's subpath imports (canonical-runtime-event, tool-ledger-scanner) and main's new orchestration imports
• execution-stores.test.ts: deleted upstream (refactor(storage): make SQLite the sole operational authority #1994) — the PR's import migration on it is moot, deletion kept
• New consumers main/upstream introduced for the removed barrel values were migrated to subpaths: ai-sdk-backend.ts (stripUndefinedDeep → @maka/core/tool-args-identity), runtime-host execution-host tests (canonicalToolArgsHash → subpath), conversation-copy test (canonicalToolArgsHash → subpath, workspace store import per upstream)

The two P2s from the review are addressed on the head:

• P2 regression guard: re-landed in executable form — apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts spawns a child Node process with a loader hook that throws on any node:* import, then imports the built@maka/core barrel; passes locally (1/1)
• P2 remaining Node-only value exports: tool-ledger-scanner, tool-args-identity, canonical-runtime-event, tool-recovery-bundle are now type-only (or absent) in the barrel; value consumers route through the existing subpaths

Local validation: full build:test clean, core suite 772/772, ai-sdk-backend 175/175, barrel regression guard passes, biome lint clean. (Storage/runtime-host sqlite & git-marker tests fail on this Windows box due to temp-dir junction/EBUSY lock issues — pre-existing environment noise, unaffected by this PR.)

[Astro-Han]

Thanks — the revised direction looks sound. Moving Node-only value exports behind the existing subpaths keeps the renderer-facing @maka/core root browser-safe without introducing a parallel implementation, and the built-artifact loader guard is the right level of protection.

The earlier review concerns appear resolved. The remaining work is mainly integration with current main:

P2 — Please rebase and preserve the browser-safe root invariant while resolving conflicts

This branch now conflicts with main, which has since added or restored more root-barrel values and consumers, including Node-dependent paths. A mechanical conflict resolution could either reintroduce the renderer boundary problem or remove exports that current consumers need.

Please rebase onto the latest main, move any newly exposed Node-only values to their existing subpaths as needed, and make sure the built-artifact guard still passes on the resulting tree.

P3 — The test comments overstate the reproduced failure mechanism

The comments currently say that Vite imports of node:* fail before createRoot() and that the loader hook mirrors the renderer. The PR description now correctly treats this as defensive hardening rather than a confirmed reproduction of the original white-screen mechanism.

It would be more accurate to describe the test as intentionally enforcing a stronger structural invariant: the renderer-facing root barrel must remain loadable without Node built-ins, regardless of current tree-shaking behavior.

The unused FIXTURES_DIR constant can also be removed while touching the test.

The implementation itself does not need another redesign. After the rebase and a fresh CI run, this should be ready for another quick review. Thanks!

[sunheyi6]

Summary

Defensive hardening of the renderer-facing @maka/core barrel: the browser-consumed barrel no longer value-exports any module whose implementation depends on node:*, and an executable regression guard prevents the Node-only export graph from returning to the renderer entry path.

Scope (per review 4bd7b29a, re-scoped from "fix" to defensive hardening — the white-screen mechanism was not reproducible under the pinned Vite 8.1.5 toolchain, where tree-shaking removes the node:* references and dev-mode proxies throw only on call, not on import):

• packages/core/src/index.ts — drop value exports for tool-ledger-scanner (node:util), tool-args-identity (node:crypto), canonical-runtime-event (node:util), and tool-recovery-bundle (node:crypto); keep only type exports in the barrel. The explicit subpaths (@maka/core/tool-args-identity, @maka/core/tool-ledger-scanner, @maka/core/canonical-runtime-event, @maka/core/tool-recovery-bundle, @maka/core/runtime-boundary) already exist in package.json exports and now carry the value consumers (runtime, storage, runtime-host).
• apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts (+ fixtures) — re-lands the regression guard in executable form against the built barrel artifact the renderer actually consumes: a child Node process registers a loader hook that throws on every node:* import and then imports @maka/core; it exits non-zero the moment the barrel graph evaluates Node-only code. This replaces the source-regex contract pruned by chore: prune source-regex tests and parallelize the e2e suite #1727.

Why defensive

Under the pinned toolchain the production renderer bundle tree-shakes the node:* references and dev mode never calls the proxied functions, so there is no current white screen — but the invariant ("importing @maka/core in a browser-like environment evaluates no node:* module") relied on tree-shaking luck rather than construction. Keeping Node-only values behind explicit subpaths makes the boundary structural and test-enforced.

Validation

• npm test (full suite: clean + build:test + script tests + all workspace test:dist)
• new regression guard passes: importing built @maka/core evaluates no node:* module
• Biome check and git diff --check

[Astro-Han]

Reviewed the current head. Moving runtime-boundary values to the existing subpath fixes the renderer import boundary without adding a second implementation. The renderer build and CI coverage are appropriate. No findings.

The branch currently conflicts with main, so the resolved head will need another review.

[Astro-Han]

Review findings (independent deepseek-v4-flash review, 2 passes)

The fix itself (moving runtime-boundary value exports out of the core barrel) is correct and mechanically complete — but the earlier approval no longer covers the head (the merge commits changed the branch), and two P2s need a decision.

P2 — the startup contract test you added was swallowed by the merge; the head has no regression guard

startup-loading-shell-contract.test.ts (3 tests added in 6da3471be, including the barrel-purity assertion) was deleted on main by #1727 and the merge commit fc099b75 kept main's deletion — git ls-tree 4bd7b29a has no such file. The PR body's "startup loading shell contract: 3 passed" verification is therefore not reproducible on the current head, and the exact #1573 regression class this PR fixes can silently return. Please re-land the contract in an executable form (e.g. assert the renderer build output contains no node: imports rather than a source-regex test), or explicitly defer with a reason.

P2 — the barrel still value-exports 3 other Node-only modules; the new comment overstates the invariant

packages/core/src/index.ts:255-260 (tool-ledger-scanner → node:util), :291 (tool-args-identity → node:crypto), :292-295 (canonical-runtime-event → node:util), and :285-290 (tool-recovery-bundle → node:crypto) are still value-exports, while :304-306 claims "renderer imports of @maka/core do not evaluate Node-only modules". Today the renderer graph happens to tree-shake them (verified: 0 node: references in the production bundle; dev-mode Vite uses a browser-external proxy that only throws on call, not on import), so there is no current white screen — but the fix relies on luck, not construction. Either move the remaining Node-only value exports behind subpaths (the subpaths already exist in package.json exports), or correct the comment to state the actual invariant.

Needs discussion — the root-cause mechanism is not reproducible with the pinned toolchain

We rebuilt the PR base (barrel with runtime-boundary value export), the head, and the fix-parent state with the pinned Vite 8.1.5: the production renderer build succeeds in all three states with zero node: references (tree-shaken), and dev mode does not throw on module evaluation (the proxy throws only when a function is called; the renderer never calls them). Current main re-added all four value exports and the renderer still works. If the mechanism is "barrel evaluation of node:crypto throws before createRoot", it doesn't hold under the pinned toolchain — the white screen you observed may have a different root cause, and this PR may be defensive hardening rather than the fix. Please reproduce the original white screen on a clean environment with the pinned toolchain (with bundle evidence), or re-scope the PR as defensive hardening.

Gate: no P0/P1 → not a FAIL; the two P2s need to be handled (fix or explicit deferral) before merge.

[sunheyi6]

Merged latest main (incl. upstream 13cf3e6) into the branch and resolved all conflicts — the PR is now mergeable.

Conflict resolution notes:

• packages/core/src/index.ts: kept this PR's hardening (Node-only value exports stay type-only/absent in the barrel) against main re-adding them
• packages/storage/src/agent-run-store.ts: kept both the PR's subpath imports (canonical-runtime-event, tool-ledger-scanner) and main's new orchestration imports
• execution-stores.test.ts: deleted upstream (refactor(storage): make SQLite the sole operational authority #1994) — the PR's import migration on it is moot, deletion kept
• New consumers main/upstream introduced for the removed barrel values were migrated to subpaths: ai-sdk-backend.ts (stripUndefinedDeep → @maka/core/tool-args-identity), runtime-host execution-host tests (canonicalToolArgsHash → subpath), conversation-copy test (canonicalToolArgsHash → subpath, workspace store import per upstream)

The two P2s from the review are addressed on the head:

• P2 regression guard: re-landed in executable form — apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts spawns a child Node process with a loader hook that throws on any node:* import, then imports the built@maka/core barrel; passes locally (1/1)
• P2 remaining Node-only value exports: tool-ledger-scanner, tool-args-identity, canonical-runtime-event, tool-recovery-bundle are now type-only (or absent) in the barrel; value consumers route through the existing subpaths

Local validation: full build:test clean, core suite 772/772, ai-sdk-backend 175/175, barrel regression guard passes, biome lint clean. (Storage/runtime-host sqlite & git-marker tests fail on this Windows box due to temp-dir junction/EBUSY lock issues — pre-existing environment noise, unaffected by this PR.)

[Astro-Han]

Thanks — the revised direction looks sound. Moving Node-only value exports behind the existing subpaths keeps the renderer-facing @maka/core root browser-safe without introducing a parallel implementation, and the built-artifact loader guard is the right level of protection.

The earlier review concerns appear resolved. The remaining work is mainly integration with current main:

P2 — Please rebase and preserve the browser-safe root invariant while resolving conflicts

This branch now conflicts with main, which has since added or restored more root-barrel values and consumers, including Node-dependent paths. A mechanical conflict resolution could either reintroduce the renderer boundary problem or remove exports that current consumers need.

Please rebase onto the latest main, move any newly exposed Node-only values to their existing subpaths as needed, and make sure the built-artifact guard still passes on the resulting tree.

P3 — The test comments overstate the reproduced failure mechanism

The comments currently say that Vite imports of node:* fail before createRoot() and that the loader hook mirrors the renderer. The PR description now correctly treats this as defensive hardening rather than a confirmed reproduction of the original white-screen mechanism.

It would be more accurate to describe the test as intentionally enforcing a stronger structural invariant: the renderer-facing root barrel must remain loadable without Node built-ins, regardless of current tree-shaking behavior.

The unused FIXTURES_DIR constant can also be removed while touching the test.

The implementation itself does not need another redesign. After the rebase and a fresh CI run, this should be ready for another quick review. Thanks!

[sunheyi6]

Summary

Defensive hardening of the renderer-facing @maka/core barrel: the browser-consumed barrel no longer value-exports any module whose implementation depends on node:*, and an executable regression guard prevents the Node-only export graph from returning to the renderer entry path.

Scope (per review 4bd7b29a, re-scoped from "fix" to defensive hardening — the white-screen mechanism was not reproducible under the pinned Vite 8.1.5 toolchain, where tree-shaking removes the node:* references and dev-mode proxies throw only on call, not on import):

• packages/core/src/index.ts — drop value exports for tool-ledger-scanner (node:util), tool-args-identity (node:crypto), canonical-runtime-event (node:util), and tool-recovery-bundle (node:crypto); keep only type exports in the barrel. The explicit subpaths (@maka/core/tool-args-identity, @maka/core/tool-ledger-scanner, @maka/core/canonical-runtime-event, @maka/core/tool-recovery-bundle, @maka/core/runtime-boundary) already exist in package.json exports and now carry the value consumers (runtime, storage, runtime-host).
• apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts (+ fixtures) — re-lands the regression guard in executable form against the built barrel artifact the renderer actually consumes: a child Node process registers a loader hook that throws on every node:* import and then imports @maka/core; it exits non-zero the moment the barrel graph evaluates Node-only code. This replaces the source-regex contract pruned by chore: prune source-regex tests and parallelize the e2e suite #1727.

Why defensive

Under the pinned toolchain the production renderer bundle tree-shakes the node:* references and dev mode never calls the proxied functions, so there is no current white screen — but the invariant ("importing @maka/core in a browser-like environment evaluates no node:* module") relied on tree-shaking luck rather than construction. Keeping Node-only values behind explicit subpaths makes the boundary structural and test-enforced.

Validation

• npm test (full suite: clean + build:test + script tests + all workspace test:dist)
• new regression guard passes: importing built @maka/core evaluates no node:* module
• Biome check and git diff --check

[Astro-Han]

Reviewed the current head. Moving runtime-boundary values to the existing subpath fixes the renderer import boundary without adding a second implementation. The renderer build and CI coverage are appropriate. No findings.

The branch currently conflicts with main, so the resolved head will need another review.

[Astro-Han]

Review findings (independent deepseek-v4-flash review, 2 passes)

The fix itself (moving runtime-boundary value exports out of the core barrel) is correct and mechanically complete — but the earlier approval no longer covers the head (the merge commits changed the branch), and two P2s need a decision.

P2 — the startup contract test you added was swallowed by the merge; the head has no regression guard

startup-loading-shell-contract.test.ts (3 tests added in 6da3471be, including the barrel-purity assertion) was deleted on main by #1727 and the merge commit fc099b75 kept main's deletion — git ls-tree 4bd7b29a has no such file. The PR body's "startup loading shell contract: 3 passed" verification is therefore not reproducible on the current head, and the exact #1573 regression class this PR fixes can silently return. Please re-land the contract in an executable form (e.g. assert the renderer build output contains no node: imports rather than a source-regex test), or explicitly defer with a reason.

P2 — the barrel still value-exports 3 other Node-only modules; the new comment overstates the invariant

packages/core/src/index.ts:255-260 (tool-ledger-scanner → node:util), :291 (tool-args-identity → node:crypto), :292-295 (canonical-runtime-event → node:util), and :285-290 (tool-recovery-bundle → node:crypto) are still value-exports, while :304-306 claims "renderer imports of @maka/core do not evaluate Node-only modules". Today the renderer graph happens to tree-shake them (verified: 0 node: references in the production bundle; dev-mode Vite uses a browser-external proxy that only throws on call, not on import), so there is no current white screen — but the fix relies on luck, not construction. Either move the remaining Node-only value exports behind subpaths (the subpaths already exist in package.json exports), or correct the comment to state the actual invariant.

Needs discussion — the root-cause mechanism is not reproducible with the pinned toolchain

We rebuilt the PR base (barrel with runtime-boundary value export), the head, and the fix-parent state with the pinned Vite 8.1.5: the production renderer build succeeds in all three states with zero node: references (tree-shaken), and dev mode does not throw on module evaluation (the proxy throws only when a function is called; the renderer never calls them). Current main re-added all four value exports and the renderer still works. If the mechanism is "barrel evaluation of node:crypto throws before createRoot", it doesn't hold under the pinned toolchain — the white screen you observed may have a different root cause, and this PR may be defensive hardening rather than the fix. Please reproduce the original white screen on a clean environment with the pinned toolchain (with bundle evidence), or re-scope the PR as defensive hardening.

Gate: no P0/P1 → not a FAIL; the two P2s need to be handled (fix or explicit deferral) before merge.

[sunheyi6]

Merged latest main (incl. upstream 13cf3e6) into the branch and resolved all conflicts — the PR is now mergeable.

Conflict resolution notes:

• packages/core/src/index.ts: kept this PR's hardening (Node-only value exports stay type-only/absent in the barrel) against main re-adding them
• packages/storage/src/agent-run-store.ts: kept both the PR's subpath imports (canonical-runtime-event, tool-ledger-scanner) and main's new orchestration imports
• execution-stores.test.ts: deleted upstream (refactor(storage): make SQLite the sole operational authority #1994) — the PR's import migration on it is moot, deletion kept
• New consumers main/upstream introduced for the removed barrel values were migrated to subpaths: ai-sdk-backend.ts (stripUndefinedDeep → @maka/core/tool-args-identity), runtime-host execution-host tests (canonicalToolArgsHash → subpath), conversation-copy test (canonicalToolArgsHash → subpath, workspace store import per upstream)

The two P2s from the review are addressed on the head:

• P2 regression guard: re-landed in executable form — apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts spawns a child Node process with a loader hook that throws on any node:* import, then imports the built@maka/core barrel; passes locally (1/1)
• P2 remaining Node-only value exports: tool-ledger-scanner, tool-args-identity, canonical-runtime-event, tool-recovery-bundle are now type-only (or absent) in the barrel; value consumers route through the existing subpaths

Local validation: full build:test clean, core suite 772/772, ai-sdk-backend 175/175, barrel regression guard passes, biome lint clean. (Storage/runtime-host sqlite & git-marker tests fail on this Windows box due to temp-dir junction/EBUSY lock issues — pre-existing environment noise, unaffected by this PR.)

[Astro-Han]

Thanks — the revised direction looks sound. Moving Node-only value exports behind the existing subpaths keeps the renderer-facing @maka/core root browser-safe without introducing a parallel implementation, and the built-artifact loader guard is the right level of protection.

The earlier review concerns appear resolved. The remaining work is mainly integration with current main:

P2 — Please rebase and preserve the browser-safe root invariant while resolving conflicts

This branch now conflicts with main, which has since added or restored more root-barrel values and consumers, including Node-dependent paths. A mechanical conflict resolution could either reintroduce the renderer boundary problem or remove exports that current consumers need.

Please rebase onto the latest main, move any newly exposed Node-only values to their existing subpaths as needed, and make sure the built-artifact guard still passes on the resulting tree.

P3 — The test comments overstate the reproduced failure mechanism

The comments currently say that Vite imports of node:* fail before createRoot() and that the loader hook mirrors the renderer. The PR description now correctly treats this as defensive hardening rather than a confirmed reproduction of the original white-screen mechanism.

It would be more accurate to describe the test as intentionally enforcing a stronger structural invariant: the renderer-facing root barrel must remain loadable without Node built-ins, regardless of current tree-shaking behavior.

The unused FIXTURES_DIR constant can also be removed while touching the test.

The implementation itself does not need another redesign. After the rebase and a fresh CI run, this should be ready for another quick review. Thanks!

[sunheyi6]

Summary

Defensive hardening of the renderer-facing @maka/core barrel: the browser-consumed barrel no longer value-exports any module whose implementation depends on node:*, and an executable regression guard prevents the Node-only export graph from returning to the renderer entry path.

Scope (per review 4bd7b29a, re-scoped from "fix" to defensive hardening — the white-screen mechanism was not reproducible under the pinned Vite 8.1.5 toolchain, where tree-shaking removes the node:* references and dev-mode proxies throw only on call, not on import):

• packages/core/src/index.ts — drop value exports for tool-ledger-scanner (node:util), tool-args-identity (node:crypto), canonical-runtime-event (node:util), and tool-recovery-bundle (node:crypto); keep only type exports in the barrel. The explicit subpaths (@maka/core/tool-args-identity, @maka/core/tool-ledger-scanner, @maka/core/canonical-runtime-event, @maka/core/tool-recovery-bundle, @maka/core/runtime-boundary) already exist in package.json exports and now carry the value consumers (runtime, storage, runtime-host).
• apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts (+ fixtures) — re-lands the regression guard in executable form against the built barrel artifact the renderer actually consumes: a child Node process registers a loader hook that throws on every node:* import and then imports @maka/core; it exits non-zero the moment the barrel graph evaluates Node-only code. This replaces the source-regex contract pruned by chore: prune source-regex tests and parallelize the e2e suite #1727.

Why defensive

Under the pinned toolchain the production renderer bundle tree-shakes the node:* references and dev mode never calls the proxied functions, so there is no current white screen — but the invariant ("importing @maka/core in a browser-like environment evaluates no node:* module") relied on tree-shaking luck rather than construction. Keeping Node-only values behind explicit subpaths makes the boundary structural and test-enforced.

Validation

• npm test (full suite: clean + build:test + script tests + all workspace test:dist)
• new regression guard passes: importing built @maka/core evaluates no node:* module
• Biome check and git diff --check

[Astro-Han]

Reviewed the current head. Moving runtime-boundary values to the existing subpath fixes the renderer import boundary without adding a second implementation. The renderer build and CI coverage are appropriate. No findings.

The branch currently conflicts with main, so the resolved head will need another review.

[Astro-Han]

Review findings (independent deepseek-v4-flash review, 2 passes)

The fix itself (moving runtime-boundary value exports out of the core barrel) is correct and mechanically complete — but the earlier approval no longer covers the head (the merge commits changed the branch), and two P2s need a decision.

P2 — the startup contract test you added was swallowed by the merge; the head has no regression guard

startup-loading-shell-contract.test.ts (3 tests added in 6da3471be, including the barrel-purity assertion) was deleted on main by #1727 and the merge commit fc099b75 kept main's deletion — git ls-tree 4bd7b29a has no such file. The PR body's "startup loading shell contract: 3 passed" verification is therefore not reproducible on the current head, and the exact #1573 regression class this PR fixes can silently return. Please re-land the contract in an executable form (e.g. assert the renderer build output contains no node: imports rather than a source-regex test), or explicitly defer with a reason.

P2 — the barrel still value-exports 3 other Node-only modules; the new comment overstates the invariant

packages/core/src/index.ts:255-260 (tool-ledger-scanner → node:util), :291 (tool-args-identity → node:crypto), :292-295 (canonical-runtime-event → node:util), and :285-290 (tool-recovery-bundle → node:crypto) are still value-exports, while :304-306 claims "renderer imports of @maka/core do not evaluate Node-only modules". Today the renderer graph happens to tree-shake them (verified: 0 node: references in the production bundle; dev-mode Vite uses a browser-external proxy that only throws on call, not on import), so there is no current white screen — but the fix relies on luck, not construction. Either move the remaining Node-only value exports behind subpaths (the subpaths already exist in package.json exports), or correct the comment to state the actual invariant.

Needs discussion — the root-cause mechanism is not reproducible with the pinned toolchain

We rebuilt the PR base (barrel with runtime-boundary value export), the head, and the fix-parent state with the pinned Vite 8.1.5: the production renderer build succeeds in all three states with zero node: references (tree-shaken), and dev mode does not throw on module evaluation (the proxy throws only when a function is called; the renderer never calls them). Current main re-added all four value exports and the renderer still works. If the mechanism is "barrel evaluation of node:crypto throws before createRoot", it doesn't hold under the pinned toolchain — the white screen you observed may have a different root cause, and this PR may be defensive hardening rather than the fix. Please reproduce the original white screen on a clean environment with the pinned toolchain (with bundle evidence), or re-scope the PR as defensive hardening.

Gate: no P0/P1 → not a FAIL; the two P2s need to be handled (fix or explicit deferral) before merge.

[sunheyi6]

Merged latest main (incl. upstream 13cf3e6) into the branch and resolved all conflicts — the PR is now mergeable.

Conflict resolution notes:

• packages/core/src/index.ts: kept this PR's hardening (Node-only value exports stay type-only/absent in the barrel) against main re-adding them
• packages/storage/src/agent-run-store.ts: kept both the PR's subpath imports (canonical-runtime-event, tool-ledger-scanner) and main's new orchestration imports
• execution-stores.test.ts: deleted upstream (refactor(storage): make SQLite the sole operational authority #1994) — the PR's import migration on it is moot, deletion kept
• New consumers main/upstream introduced for the removed barrel values were migrated to subpaths: ai-sdk-backend.ts (stripUndefinedDeep → @maka/core/tool-args-identity), runtime-host execution-host tests (canonicalToolArgsHash → subpath), conversation-copy test (canonicalToolArgsHash → subpath, workspace store import per upstream)

The two P2s from the review are addressed on the head:

• P2 regression guard: re-landed in executable form — apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts spawns a child Node process with a loader hook that throws on any node:* import, then imports the built@maka/core barrel; passes locally (1/1)
• P2 remaining Node-only value exports: tool-ledger-scanner, tool-args-identity, canonical-runtime-event, tool-recovery-bundle are now type-only (or absent) in the barrel; value consumers route through the existing subpaths

Local validation: full build:test clean, core suite 772/772, ai-sdk-backend 175/175, barrel regression guard passes, biome lint clean. (Storage/runtime-host sqlite & git-marker tests fail on this Windows box due to temp-dir junction/EBUSY lock issues — pre-existing environment noise, unaffected by this PR.)

[Astro-Han]

Thanks — the revised direction looks sound. Moving Node-only value exports behind the existing subpaths keeps the renderer-facing @maka/core root browser-safe without introducing a parallel implementation, and the built-artifact loader guard is the right level of protection.

The earlier review concerns appear resolved. The remaining work is mainly integration with current main:

P2 — Please rebase and preserve the browser-safe root invariant while resolving conflicts

This branch now conflicts with main, which has since added or restored more root-barrel values and consumers, including Node-dependent paths. A mechanical conflict resolution could either reintroduce the renderer boundary problem or remove exports that current consumers need.

Please rebase onto the latest main, move any newly exposed Node-only values to their existing subpaths as needed, and make sure the built-artifact guard still passes on the resulting tree.

P3 — The test comments overstate the reproduced failure mechanism

The comments currently say that Vite imports of node:* fail before createRoot() and that the loader hook mirrors the renderer. The PR description now correctly treats this as defensive hardening rather than a confirmed reproduction of the original white-screen mechanism.

It would be more accurate to describe the test as intentionally enforcing a stronger structural invariant: the renderer-facing root barrel must remain loadable without Node built-ins, regardless of current tree-shaking behavior.

The unused FIXTURES_DIR constant can also be removed while touching the test.

The implementation itself does not need another redesign. After the rebase and a fresh CI run, this should be ready for another quick review. Thanks!

[sunheyi6]

Summary

Defensive hardening of the renderer-facing @maka/core barrel: the browser-consumed barrel no longer value-exports any module whose implementation depends on node:*, and an executable regression guard prevents the Node-only export graph from returning to the renderer entry path.

Scope (per review 4bd7b29a, re-scoped from "fix" to defensive hardening — the white-screen mechanism was not reproducible under the pinned Vite 8.1.5 toolchain, where tree-shaking removes the node:* references and dev-mode proxies throw only on call, not on import):

• packages/core/src/index.ts — drop value exports for tool-ledger-scanner (node:util), tool-args-identity (node:crypto), canonical-runtime-event (node:util), and tool-recovery-bundle (node:crypto); keep only type exports in the barrel. The explicit subpaths (@maka/core/tool-args-identity, @maka/core/tool-ledger-scanner, @maka/core/canonical-runtime-event, @maka/core/tool-recovery-bundle, @maka/core/runtime-boundary) already exist in package.json exports and now carry the value consumers (runtime, storage, runtime-host).
• apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts (+ fixtures) — re-lands the regression guard in executable form against the built barrel artifact the renderer actually consumes: a child Node process registers a loader hook that throws on every node:* import and then imports @maka/core; it exits non-zero the moment the barrel graph evaluates Node-only code. This replaces the source-regex contract pruned by chore: prune source-regex tests and parallelize the e2e suite #1727.

Why defensive

Under the pinned toolchain the production renderer bundle tree-shakes the node:* references and dev mode never calls the proxied functions, so there is no current white screen — but the invariant ("importing @maka/core in a browser-like environment evaluates no node:* module") relied on tree-shaking luck rather than construction. Keeping Node-only values behind explicit subpaths makes the boundary structural and test-enforced.

Validation

• npm test (full suite: clean + build:test + script tests + all workspace test:dist)
• new regression guard passes: importing built @maka/core evaluates no node:* module
• Biome check and git diff --check

[Astro-Han]

Reviewed the current head. Moving runtime-boundary values to the existing subpath fixes the renderer import boundary without adding a second implementation. The renderer build and CI coverage are appropriate. No findings.

The branch currently conflicts with main, so the resolved head will need another review.

[Astro-Han]

Review findings (independent deepseek-v4-flash review, 2 passes)

The fix itself (moving runtime-boundary value exports out of the core barrel) is correct and mechanically complete — but the earlier approval no longer covers the head (the merge commits changed the branch), and two P2s need a decision.

P2 — the startup contract test you added was swallowed by the merge; the head has no regression guard

startup-loading-shell-contract.test.ts (3 tests added in 6da3471be, including the barrel-purity assertion) was deleted on main by #1727 and the merge commit fc099b75 kept main's deletion — git ls-tree 4bd7b29a has no such file. The PR body's "startup loading shell contract: 3 passed" verification is therefore not reproducible on the current head, and the exact #1573 regression class this PR fixes can silently return. Please re-land the contract in an executable form (e.g. assert the renderer build output contains no node: imports rather than a source-regex test), or explicitly defer with a reason.

P2 — the barrel still value-exports 3 other Node-only modules; the new comment overstates the invariant

packages/core/src/index.ts:255-260 (tool-ledger-scanner → node:util), :291 (tool-args-identity → node:crypto), :292-295 (canonical-runtime-event → node:util), and :285-290 (tool-recovery-bundle → node:crypto) are still value-exports, while :304-306 claims "renderer imports of @maka/core do not evaluate Node-only modules". Today the renderer graph happens to tree-shake them (verified: 0 node: references in the production bundle; dev-mode Vite uses a browser-external proxy that only throws on call, not on import), so there is no current white screen — but the fix relies on luck, not construction. Either move the remaining Node-only value exports behind subpaths (the subpaths already exist in package.json exports), or correct the comment to state the actual invariant.

Needs discussion — the root-cause mechanism is not reproducible with the pinned toolchain

We rebuilt the PR base (barrel with runtime-boundary value export), the head, and the fix-parent state with the pinned Vite 8.1.5: the production renderer build succeeds in all three states with zero node: references (tree-shaken), and dev mode does not throw on module evaluation (the proxy throws only when a function is called; the renderer never calls them). Current main re-added all four value exports and the renderer still works. If the mechanism is "barrel evaluation of node:crypto throws before createRoot", it doesn't hold under the pinned toolchain — the white screen you observed may have a different root cause, and this PR may be defensive hardening rather than the fix. Please reproduce the original white screen on a clean environment with the pinned toolchain (with bundle evidence), or re-scope the PR as defensive hardening.

Gate: no P0/P1 → not a FAIL; the two P2s need to be handled (fix or explicit deferral) before merge.

[sunheyi6]

Merged latest main (incl. upstream 13cf3e6) into the branch and resolved all conflicts — the PR is now mergeable.

Conflict resolution notes:

• packages/core/src/index.ts: kept this PR's hardening (Node-only value exports stay type-only/absent in the barrel) against main re-adding them
• packages/storage/src/agent-run-store.ts: kept both the PR's subpath imports (canonical-runtime-event, tool-ledger-scanner) and main's new orchestration imports
• execution-stores.test.ts: deleted upstream (refactor(storage): make SQLite the sole operational authority #1994) — the PR's import migration on it is moot, deletion kept
• New consumers main/upstream introduced for the removed barrel values were migrated to subpaths: ai-sdk-backend.ts (stripUndefinedDeep → @maka/core/tool-args-identity), runtime-host execution-host tests (canonicalToolArgsHash → subpath), conversation-copy test (canonicalToolArgsHash → subpath, workspace store import per upstream)

The two P2s from the review are addressed on the head:

• P2 regression guard: re-landed in executable form — apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts spawns a child Node process with a loader hook that throws on any node:* import, then imports the built@maka/core barrel; passes locally (1/1)
• P2 remaining Node-only value exports: tool-ledger-scanner, tool-args-identity, canonical-runtime-event, tool-recovery-bundle are now type-only (or absent) in the barrel; value consumers route through the existing subpaths

Local validation: full build:test clean, core suite 772/772, ai-sdk-backend 175/175, barrel regression guard passes, biome lint clean. (Storage/runtime-host sqlite & git-marker tests fail on this Windows box due to temp-dir junction/EBUSY lock issues — pre-existing environment noise, unaffected by this PR.)

[Astro-Han]

Thanks — the revised direction looks sound. Moving Node-only value exports behind the existing subpaths keeps the renderer-facing @maka/core root browser-safe without introducing a parallel implementation, and the built-artifact loader guard is the right level of protection.

The earlier review concerns appear resolved. The remaining work is mainly integration with current main:

P2 — Please rebase and preserve the browser-safe root invariant while resolving conflicts

This branch now conflicts with main, which has since added or restored more root-barrel values and consumers, including Node-dependent paths. A mechanical conflict resolution could either reintroduce the renderer boundary problem or remove exports that current consumers need.

Please rebase onto the latest main, move any newly exposed Node-only values to their existing subpaths as needed, and make sure the built-artifact guard still passes on the resulting tree.

P3 — The test comments overstate the reproduced failure mechanism

The comments currently say that Vite imports of node:* fail before createRoot() and that the loader hook mirrors the renderer. The PR description now correctly treats this as defensive hardening rather than a confirmed reproduction of the original white-screen mechanism.

It would be more accurate to describe the test as intentionally enforcing a stronger structural invariant: the renderer-facing root barrel must remain loadable without Node built-ins, regardless of current tree-shaking behavior.

The unused FIXTURES_DIR constant can also be removed while touching the test.

The implementation itself does not need another redesign. After the rebase and a fresh CI run, this should be ready for another quick review. Thanks!

[sunheyi6]

Summary

Defensive hardening of the renderer-facing @maka/core barrel: the browser-consumed barrel no longer value-exports any module whose implementation depends on node:*, and an executable regression guard prevents the Node-only export graph from returning to the renderer entry path.

Scope (per review 4bd7b29a, re-scoped from "fix" to defensive hardening — the white-screen mechanism was not reproducible under the pinned Vite 8.1.5 toolchain, where tree-shaking removes the node:* references and dev-mode proxies throw only on call, not on import):

• packages/core/src/index.ts — drop value exports for tool-ledger-scanner (node:util), tool-args-identity (node:crypto), canonical-runtime-event (node:util), and tool-recovery-bundle (node:crypto); keep only type exports in the barrel. The explicit subpaths (@maka/core/tool-args-identity, @maka/core/tool-ledger-scanner, @maka/core/canonical-runtime-event, @maka/core/tool-recovery-bundle, @maka/core/runtime-boundary) already exist in package.json exports and now carry the value consumers (runtime, storage, runtime-host).
• apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts (+ fixtures) — re-lands the regression guard in executable form against the built barrel artifact the renderer actually consumes: a child Node process registers a loader hook that throws on every node:* import and then imports @maka/core; it exits non-zero the moment the barrel graph evaluates Node-only code. This replaces the source-regex contract pruned by chore: prune source-regex tests and parallelize the e2e suite #1727.

Why defensive

Under the pinned toolchain the production renderer bundle tree-shakes the node:* references and dev mode never calls the proxied functions, so there is no current white screen — but the invariant ("importing @maka/core in a browser-like environment evaluates no node:* module") relied on tree-shaking luck rather than construction. Keeping Node-only values behind explicit subpaths makes the boundary structural and test-enforced.

Validation

• npm test (full suite: clean + build:test + script tests + all workspace test:dist)
• new regression guard passes: importing built @maka/core evaluates no node:* module
• Biome check and git diff --check

[Astro-Han]

Reviewed the current head. Moving runtime-boundary values to the existing subpath fixes the renderer import boundary without adding a second implementation. The renderer build and CI coverage are appropriate. No findings.

The branch currently conflicts with main, so the resolved head will need another review.

[Astro-Han]

Review findings (independent deepseek-v4-flash review, 2 passes)

The fix itself (moving runtime-boundary value exports out of the core barrel) is correct and mechanically complete — but the earlier approval no longer covers the head (the merge commits changed the branch), and two P2s need a decision.

P2 — the startup contract test you added was swallowed by the merge; the head has no regression guard

startup-loading-shell-contract.test.ts (3 tests added in 6da3471be, including the barrel-purity assertion) was deleted on main by #1727 and the merge commit fc099b75 kept main's deletion — git ls-tree 4bd7b29a has no such file. The PR body's "startup loading shell contract: 3 passed" verification is therefore not reproducible on the current head, and the exact #1573 regression class this PR fixes can silently return. Please re-land the contract in an executable form (e.g. assert the renderer build output contains no node: imports rather than a source-regex test), or explicitly defer with a reason.

P2 — the barrel still value-exports 3 other Node-only modules; the new comment overstates the invariant

packages/core/src/index.ts:255-260 (tool-ledger-scanner → node:util), :291 (tool-args-identity → node:crypto), :292-295 (canonical-runtime-event → node:util), and :285-290 (tool-recovery-bundle → node:crypto) are still value-exports, while :304-306 claims "renderer imports of @maka/core do not evaluate Node-only modules". Today the renderer graph happens to tree-shake them (verified: 0 node: references in the production bundle; dev-mode Vite uses a browser-external proxy that only throws on call, not on import), so there is no current white screen — but the fix relies on luck, not construction. Either move the remaining Node-only value exports behind subpaths (the subpaths already exist in package.json exports), or correct the comment to state the actual invariant.

Needs discussion — the root-cause mechanism is not reproducible with the pinned toolchain

We rebuilt the PR base (barrel with runtime-boundary value export), the head, and the fix-parent state with the pinned Vite 8.1.5: the production renderer build succeeds in all three states with zero node: references (tree-shaken), and dev mode does not throw on module evaluation (the proxy throws only when a function is called; the renderer never calls them). Current main re-added all four value exports and the renderer still works. If the mechanism is "barrel evaluation of node:crypto throws before createRoot", it doesn't hold under the pinned toolchain — the white screen you observed may have a different root cause, and this PR may be defensive hardening rather than the fix. Please reproduce the original white screen on a clean environment with the pinned toolchain (with bundle evidence), or re-scope the PR as defensive hardening.

Gate: no P0/P1 → not a FAIL; the two P2s need to be handled (fix or explicit deferral) before merge.

[sunheyi6]

Merged latest main (incl. upstream 13cf3e6) into the branch and resolved all conflicts — the PR is now mergeable.

Conflict resolution notes:

• packages/core/src/index.ts: kept this PR's hardening (Node-only value exports stay type-only/absent in the barrel) against main re-adding them
• packages/storage/src/agent-run-store.ts: kept both the PR's subpath imports (canonical-runtime-event, tool-ledger-scanner) and main's new orchestration imports
• execution-stores.test.ts: deleted upstream (refactor(storage): make SQLite the sole operational authority #1994) — the PR's import migration on it is moot, deletion kept
• New consumers main/upstream introduced for the removed barrel values were migrated to subpaths: ai-sdk-backend.ts (stripUndefinedDeep → @maka/core/tool-args-identity), runtime-host execution-host tests (canonicalToolArgsHash → subpath), conversation-copy test (canonicalToolArgsHash → subpath, workspace store import per upstream)

The two P2s from the review are addressed on the head:

• P2 regression guard: re-landed in executable form — apps/desktop/src/main/__tests__/renderer-core-barrel-node-boundary.test.ts spawns a child Node process with a loader hook that throws on any node:* import, then imports the built@maka/core barrel; passes locally (1/1)
• P2 remaining Node-only value exports: tool-ledger-scanner, tool-args-identity, canonical-runtime-event, tool-recovery-bundle are now type-only (or absent) in the barrel; value consumers route through the existing subpaths

Local validation: full build:test clean, core suite 772/772, ai-sdk-backend 175/175, barrel regression guard passes, biome lint clean. (Storage/runtime-host sqlite & git-marker tests fail on this Windows box due to temp-dir junction/EBUSY lock issues — pre-existing environment noise, unaffected by this PR.)

[Astro-Han]

Thanks — the revised direction looks sound. Moving Node-only value exports behind the existing subpaths keeps the renderer-facing @maka/core root browser-safe without introducing a parallel implementation, and the built-artifact loader guard is the right level of protection.

The earlier review concerns appear resolved. The remaining work is mainly integration with current main:

P2 — Please rebase and preserve the browser-safe root invariant while resolving conflicts

This branch now conflicts with main, which has since added or restored more root-barrel values and consumers, including Node-dependent paths. A mechanical conflict resolution could either reintroduce the renderer boundary problem or remove exports that current consumers need.

Please rebase onto the latest main, move any newly exposed Node-only values to their existing subpaths as needed, and make sure the built-artifact guard still passes on the resulting tree.

P3 — The test comments overstate the reproduced failure mechanism

The comments currently say that Vite imports of node:* fail before createRoot() and that the loader hook mirrors the renderer. The PR description now correctly treats this as defensive hardening rather than a confirmed reproduction of the original white-screen mechanism.

It would be more accurate to describe the test as intentionally enforcing a stronger structural invariant: the renderer-facing root barrel must remain loadable without Node built-ins, regardless of current tree-shaking behavior.

The unused FIXTURES_DIR constant can also be removed while touching the test.

The implementation itself does not need another redesign. After the rebase and a fresh CI run, this should be ready for another quick review. Thanks!