catalyst-core 1.0.1-canary.1 → 1.0.1

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/utils/SafeAreaUtils.kt

@@ -31,12 +31,14 @@ object SafeAreaUtils {
      * CSS px equal dp here: the WebView has no wide-viewport scaling, so
      * devicePixelRatio == density and px / density gives CSS px.
      * - Edge-to-edge disabled: Returns ZERO (the system already insets the WebView, iOS parity)
-     * - Edge-to-edge enabled: Returns ceil(max(system bars, cutout) / density) per edge
+     * - Edge-to-edge enabled: Returns ceil(max(system bars ignoring visibility, cutout) / density) per edge
      */
     fun fromWindowInsets(insets: WindowInsetsCompat?, edgeToEdgeEnabled: Boolean, density: Float): SafeAreaInsets {
         if (insets == null || !edgeToEdgeEnabled) return SafeAreaInsets.ZERO
 
-        val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+        // Ignore visibility: the IME window hosts the nav bar, so the visible systemBars
+        // bottom grows to the keyboard height while the keyboard is open
+        val systemBars = insets.getInsetsIgnoringVisibility(WindowInsetsCompat.Type.systemBars())
         val cutoutInsets = insets.getInsets(WindowInsetsCompat.Type.displayCutout())
 
         return SafeAreaInsets(

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/utils/SafeAreaUtilsTest.kt

@@ -32,9 +32,14 @@ import org.mockito.kotlin.whenever
  */
 class SafeAreaUtilsTest {
 
-    private fun windowInsetsCompatWith(systemBars: Insets, cutout: Insets = Insets.NONE): WindowInsetsCompat {
+    private fun windowInsetsCompatWith(
+        systemBars: Insets,
+        cutout: Insets = Insets.NONE,
+        visibleSystemBars: Insets = systemBars
+    ): WindowInsetsCompat {
         return mock {
-            on { getInsets(WindowInsetsCompat.Type.systemBars()) } doReturn systemBars
+            on { getInsets(WindowInsetsCompat.Type.systemBars()) } doReturn visibleSystemBars
+            on { getInsetsIgnoringVisibility(WindowInsetsCompat.Type.systemBars()) } doReturn systemBars
             on { getInsets(WindowInsetsCompat.Type.displayCutout()) } doReturn cutout
         }
     }
@@ -128,6 +133,18 @@ class SafeAreaUtilsTest {
         assertEquals(SafeAreaInsets(top = 24, right = 0, bottom = 0, left = 0), result)
     }
 
+    @Test
+    fun `fromWindowInsets with edge-to-edge enabled ignores the IME-inflated visible system bar bottom`() {
+        val windowInsets = windowInsetsCompatWith(
+            systemBars = Insets.of(0, 0, 0, 63),
+            visibleSystemBars = Insets.of(0, 0, 0, 883)
+        )
+
+        val result = SafeAreaUtils.fromWindowInsets(windowInsets, edgeToEdgeEnabled = true, density = 2.625f)
+
+        assertEquals(SafeAreaInsets(top = 0, right = 0, bottom = 24, left = 0), result)
+    }
+
     // ============================================================
     // SafeAreaInsets.toMap()
     // ============================================================

package/dist/otel.js

@@ -294,33 +294,6 @@ export function withObservability(serviceName, fn, name) {
     }
 }
 
-/**
- * Creates a recorder for out-of-band response stream errors.
- *
- * Stream errors (e.g. Node's ERR_STREAM_WRITE_AFTER_END) surface on the
- * response object's "error" event, typically after the span that performed
- * the offending write has already ended, so recording the exception on the
- * active span at error time would be silently dropped. Instead, capture the
- * ambient context while the request span is still active and emit a dedicated
- * error span into the same trace for each stream error (the same parenting
- * approach responseFlushMiddleware uses for its post-end spans).
- *
- * @param {string} serviceName - The name of the service
- * @param {string} name - Span name (optional)
- * @returns {Function} (error) => void, safe to call after the request span ended
- */
-export function createStreamErrorRecorder(serviceName, name = "responseStreamError") {
-    const tracer = trace.getTracer(serviceName)
-    const parentContext = context.active()
-    return function recordStreamError(error) {
-        const span = tracer.startSpan(name, undefined, parentContext)
-        if (error && error.code) span.setAttribute("error.type", String(error.code))
-        span.recordException(error)
-        span.setStatus({ code: 2, message: error && error.message ? error.message : String(error) })
-        span.end()
-    }
-}
-
 /**
  * Express middleware that emits two spans describing what happens to the
  * response body AFTER the app calls res.end() — the work that lives past the
@@ -425,10 +398,4 @@ export function responseFlushMiddleware(
     }
 }
 
-export default {
-    init,
-    withObservability,
-    withSyncObservability,
-    responseFlushMiddleware,
-    createStreamErrorRecorder,
-}
+export default { init, withObservability, withSyncObservability, responseFlushMiddleware }

package/dist/server/renderer/handler.jsx

@@ -102,7 +102,6 @@ try {
 // Passthrough no-ops used when OTEL_ENABLE is not set; replaced below if enabled.
 let withObservability = (_service, fn) => fn;
 let withSyncObservability = (_service, fn) => fn;
-let createStreamErrorRecorder = null;
 
 // config.json booleans survive the process.env swap in loadEnvironmentVariables(),
 // so this is genuinely true at runtime when config sets OTEL_ENABLE: true. The cast
@@ -112,7 +111,6 @@ if (process.env.OTEL_ENABLE === true) {
     const otel = await import("../../otel.js");
     withObservability = otel.withObservability;
     withSyncObservability = otel.withSyncObservability;
-    createStreamErrorRecorder = otel.createStreamErrorRecorder;
   } catch {
     // otel packages not installed — continue without tracing
   }
@@ -168,26 +166,6 @@ const getComponent = (store, context, req, fetcherData, isBot) => <div id="app">
     </div>;
 
 // ── Render and stream ──────────────────────────────────────────────────
-// Responses that already have a stream-error listener attached. Guarded via
-// WeakSet because renderMarkUp can run twice for one response (the fetcher
-// error path re-renders with a 404) and "error" listeners must not stack.
-const _observedResponses = new WeakSet();
-
-// Node swallows response stream errors (e.g. ERR_STREAM_WRITE_AFTER_END) when
-// res has no "error" listener: the write is dropped, nothing is logged, and a
-// truncated document ships silently. Log every stream error through
-// logSSRError (RUNTIME-WEB-001, like every other SSR failure) and, when tracing
-// is enabled, record it as an error span in the request's trace. Must be
-// called while the request span is still active so the span parents correctly.
-const observeResponseStreamErrors = res => {
-  if (_observedResponses.has(res)) return;
-  _observedResponses.add(res);
-  const recordStreamError = createStreamErrorRecorder ? createStreamErrorRecorder(SSR_SERVICE) : null;
-  res.on("error", error => {
-    logSSRError("RENDER", error);
-    if (recordStreamError) recordStreamError(error);
-  });
-};
 const _renderMarkUp = async (errorCode, req, res, metaTags, fetcherData, store, allMatches, context, chunkExtractor) => {
   const deviceDetails = getUserAgentDetails(req.headers["user-agent"] || "");
   // Match mweb's wider definition: synthetic monitors (StatusCake) and AI crawlers
@@ -269,7 +247,6 @@ const _renderMarkUp = async (errorCode, req, res, metaTags, fetcherData, store,
       "content-type": "text/html; charset=utf-8"
     });
     res.status(status);
-    observeResponseStreamErrors(res);
     return new Promise((resolve, reject) => {
       // Single completion path: React's pipe() auto-ends `tail`, and
       // `flush()` appends the deferred asset tags before that end

package/dist/vite/vite.config.client.js

@@ -74,7 +74,7 @@ const createClientConfig = async () => {
                             return undefined
                         }
                         if (
-                            /[\\/]node_modules[\\/](react|react-dom|scheduler)[\\/]/.test(
+                            /[\\/]node_modules[\\/](react|react-dom|scheduler|react-fast-compare|react-side-effect|react-helmet-async)[\\/]/.test(
                                 id
                             )
                         ) {

package/dist/vite/vite.config.js

@@ -266,7 +266,9 @@ const browserOptimizeDeps = [
     "redux",
     "redux-thunk",
     "axios",
+    "react-helmet-async",
     "react-google-recaptcha",
+    "react-fast-compare",
     "history",
     "lottie-web",
     // Pre-bundle alongside React so esbuild marks react/react-router as external
@@ -293,6 +295,7 @@ const browserOptimizeDeps = [
     // first navigation that pulls them in doesn't trigger a full-page reload.
     "react-loadable-visibility",
     "react-detect-offline",
+    "react-side-effect",
     "react-async-script",
     "normalize.css",
 ]
@@ -354,6 +357,7 @@ export const sharedViteConfig = {
         optimizeDeps: {
             include: [
                 "invariant",
+                "react-fast-compare",
                 "shallowequal",
                 "prop-types",
                 "redux-thunk",

package/dist/web-router/components/MetaTag.jsx

@@ -1,7 +1,8 @@
 import React, { useContext, useState, useEffect } from "react";
+import { HelmetProvider, Helmet } from "react-helmet-async";
 import { OneMgRouterContext } from "../context.jsx";
 import { useRouterData } from "./RouterDataProvider.jsx";
-import { getMetaData } from "../utils/metaDataUtils.jsx";
+import { deleteHeadTagsByDataAttribute, getMetaData } from "../utils/metaDataUtils.jsx";
 import { useLocation } from "react-router";
 
 /**
@@ -13,13 +14,19 @@ export const MetaTag = () => {
   } = useContext(OneMgRouterContext);
   const routeData = useRouterData();
   const location = useLocation();
-  const [metaTags, setMetaTags] = useState([]);
+  const [metaTags, setMetaTags] = useState([<meta key={0}></meta>]);
   useEffect(() => {
     const mergedMetaTags = getMetaData(matchedRoutes, routeData);
-    setMetaTags(Array.isArray(mergedMetaTags) ? mergedMetaTags : []);
+    if (Array.isArray(mergedMetaTags) && mergedMetaTags.length > 0) {
+      setMetaTags(mergedMetaTags);
+    }
+    return () => deleteHeadTagsByDataAttribute("catalyst");
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [location]);
-
-  // React 19 hoists document metadata rendered by components into <head>.
-  return <>{metaTags}</>;
+  if (Array.isArray(metaTags) && metaTags.length >= 0) {
+    return <HelmetProvider>
+                <Helmet>{metaTags}</Helmet>
+            </HelmetProvider>;
+  }
+  return <></>;
 };

package/dist/web-router/components/MetaTag.test.jsx

@@ -1,7 +1,7 @@
 import React from "react"
-import { describe, expect, it, vi } from "vitest"
+import { describe, expect, it, vi, afterEach } from "vitest"
 import { render, waitFor, act } from "@testing-library/react"
-import { MemoryRouter, Routes, Route, useLocation, useNavigate } from "react-router"
+import { MemoryRouter, Routes, Route, useNavigate } from "react-router"
 import { MetaTag } from "./MetaTag.jsx"
 import { OneMgRouterContext } from "../context.jsx"
 import { RouterContext } from "./RouterDataProvider.jsx"
@@ -26,6 +26,10 @@ function renderMetaTag({ matchedRoutes = [], routerData = {} } = {}) {
 }
 
 describe("MetaTag", () => {
+    afterEach(() => {
+        document.head.innerHTML = ""
+    })
+
     it("renders without crashing when there are no matched routes", () => {
         expect(() => renderMetaTag()).not.toThrow()
     })
@@ -44,64 +48,53 @@ describe("MetaTag", () => {
         await waitFor(() => {
             expect(document.head.querySelector('meta[name="description"]')).not.toBeNull()
         })
-        expect(document.head.querySelector('meta[name="description"]').getAttribute("content")).toBe("hello")
+        expect(document.head.querySelector('meta[name="description"]').getAttribute("content")).toBe(
+            "hello"
+        )
     })
 
-    it("renders no metadata when no route provides setMetaData", () => {
+    it("keeps the placeholder meta tag when no route provides setMetaData", () => {
         renderMetaTag({ matchedRoutes: [{ route: { component: {} } }] })
-        expect(document.head.querySelector("[data-catalyst]")).toBeNull()
+        // Component should still render (Helmet/HelmetProvider tree),
+        // even with the single empty placeholder <meta> from useState.
+        expect(document.querySelector("head")).not.toBeNull()
     })
 
-    it("clears previous metadata when navigating to a route without setMetaData", async () => {
-        const routeWithMetadata = [
-            {
-                route: {
-                    component: {
-                        setMetaData: () => [<meta key="d" name="description" content="with metadata" />],
-                    },
-                },
-            },
-        ]
-
-        function RouteMetadata() {
-            const location = useLocation()
-            const matchedRoutes = location.pathname === "/with-metadata" ? routeWithMetadata : []
-
-            return (
-                <OneMgRouterContext.Provider value={{ matchedRoutes }}>
-                    <RouterContext.Provider value={{}}>
-                        <MetaTag />
-                    </RouterContext.Provider>
-                </OneMgRouterContext.Provider>
-            )
-        }
+    it("re-runs setMetaData and clears previous tags when the location changes", async () => {
+        // A rerender() with a NEW <MemoryRouter initialEntries> does not
+        // navigate an already-mounted router -- initialEntries is only
+        // read on first mount. Confirmed directly: that approach left
+        // setMetaData called once even after "changing" the path.
+        // Navigating within one mounted router (via a real useNavigate
+        // call, triggered here through a button) is what actually
+        // changes useLocation() and re-fires MetaTag's effect.
+        const setMetaData = vi.fn(() => [<meta key="d" name="description" content="v1" />])
+        const matchedRoutes = [{ route: { component: { setMetaData } } }]
 
         function NavButton() {
             const navigate = useNavigate()
             return (
-                <button type="button" onClick={() => navigate("/without-metadata")}>
+                <button type="button" onClick={() => navigate("/b")}>
                     go
                 </button>
             )
         }
 
         render(
-            <MemoryRouter initialEntries={["/with-metadata"]}>
-                <NavButton />
-                <RouteMetadata />
+            <MemoryRouter initialEntries={["/a"]}>
+                <OneMgRouterContext.Provider value={{ matchedRoutes }}>
+                    <RouterContext.Provider value={{}}>
+                        <NavButton />
+                        <MetaTag />
+                    </RouterContext.Provider>
+                </OneMgRouterContext.Provider>
             </MemoryRouter>
         )
-
-        await waitFor(() => {
-            expect(document.head.querySelector('meta[name="description"]')).not.toBeNull()
-        })
+        await waitFor(() => expect(setMetaData).toHaveBeenCalledTimes(1))
 
         await act(async () => {
             document.querySelector("button").click()
         })
-
-        await waitFor(() => {
-            expect(document.head.querySelector('meta[name="description"]')).toBeNull()
-        })
+        await waitFor(() => expect(setMetaData).toHaveBeenCalledTimes(2))
     })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "catalyst-core",
-    "version": "1.0.1-canary.1",
+    "version": "1.0.1",
     "type": "module",
     "main": "./dist/index.jsx",
     "description": "Web framework that provides great performance out of the box",
@@ -72,12 +72,13 @@
         "@vitejs/plugin-react": "^4.4.1",
         "ansis": "^4.3.1",
         "body-parser": "^1.20.2",
-        "compression": "^1.7.4",
+        "compression": "^1.8.2",
         "cookie-parser": "^1.4.6",
         "express": "^4.22.3",
         "express-static-gzip": "^2.1.7",
         "react": "19.0.0",
         "react-dom": "19.0.0",
+        "react-helmet-async": "^1.3.0",
         "react-redux": "^9.2.0",
         "react-refresh": "^0.14.0",
         "redux": "^4.2.1",
@@ -136,6 +137,10 @@
         ]
     },
     "overrides": {
+        "react-helmet-async": {
+            "react": "19.0.0",
+            "react-dom": "19.0.0"
+        },
         "react-redux": {
             "react": "19.0.0",
             "react-dom": "19.0.0"

package/test/server/handler.test.ts

@@ -160,33 +160,6 @@ describe("SSR handler", () => {
         expect(res.getHtml()).toContain("<html")
     })
 
-    it("logs a response stream error as RUNTIME-WEB-001 instead of swallowing it", async () => {
-        const { default: handler } = await import("../../src/server/renderer/handler.jsx")
-        const { req, res } = makeReqRes("/")
-
-        await handler(req, res)
-        await res.waitForEnd()
-
-        const streamError: any = new Error("write after end")
-        streamError.code = "ERR_STREAM_WRITE_AFTER_END"
-        res.emit("error", streamError)
-
-        const logged = (console.error as any).mock.calls.flat().join("\n")
-        expect(logged).toContain("RUNTIME-WEB-001")
-        expect(logged).toContain("write after end")
-    })
-
-    it("attaches one stream-error listener even when the fetcher-error path renders twice", async () => {
-        const { default: handler } = await import("../../src/server/renderer/handler.jsx")
-        const { req, res } = makeReqRes("/fetcher-error")
-        const before = res.listenerCount("error")
-
-        await handler(req, res)
-        await res.waitForEnd()
-
-        expect(res.listenerCount("error")).toBe(before + 1)
-    })
-
     it("fails the request with 500 (no render) when configureStore is not a function", async () => {
         // handler.jsx imports createStore as a module-scope default binding,
         // so swap the fixture module before the fresh import. A non-function