@taujs/server 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Aoede Ltd 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# @taujs/server
+
+Streaming React SSR & Hydration Fastify Plugin for integration with taujs [ τjs ] template
+
+TypeScript / ESM-only focus
+τjs - DX: Developer eXperience first focus. Integrated ViteDevServer HMR + Vite Runtime API run alongside tsx (TS eXecute) providing fast responsive dev reload times for both backend / frontend
+
+Build: client (Vite) & server (ESBuild + Rollup)
+
+Fastify https://fastify.dev/
+Vite https://vitejs.dev/guide/ssr#building-for-production
+React https://reactjs.org/
+
+tsx https://tsx.is/
+ViteDevServer HMR https://vitejs.dev/guide/ssr#setting-up-the-dev-server
+Vite Runtime API https://vitejs.dev/guide/api-vite-runtime
+ESBuild https://esbuild.github.io/
+Rollup https://rollupjs.org/
+ESM https://nodejs.org/api/esm.html
+
+## Development / CI
+
+    "@fastify/static": "^7.0.4",
+    "path-to-regexp": "^7.0.0"
+
+npm install --legacy-peer-deps

package/dist/SSRDataStore.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+
+type SSRStore<T> = {
+    getSnapshot: () => T;
+    getServerSnapshot: () => T;
+    setData: (newData: T) => void;
+    subscribe: (callback: () => void) => () => void;
+};
+declare const createSSRStore: <T>(initialDataPromise: Promise<T>) => SSRStore<T>;
+declare const SSRStoreProvider: React.FC<React.PropsWithChildren<{
+    store: SSRStore<Record<string, unknown>>;
+}>>;
+declare const useSSRStore: <T>() => SSRStore<T>;
+
+export { SSRStoreProvider, createSSRStore, useSSRStore };

package/dist/SSRDataStore.js

@@ -0,0 +1,58 @@
+// src/SSRDataStore.tsx
+import { createContext, useContext, useSyncExternalStore } from "react";
+import { jsx } from "react/jsx-runtime";
+var createSSRStore = (initialDataPromise) => {
+  let currentData;
+  let status = "pending";
+  const subscribers = /* @__PURE__ */ new Set();
+  let resolvePromise = null;
+  const serverDataPromise = new Promise((resolve) => resolvePromise = resolve);
+  initialDataPromise.then((data) => {
+    currentData = data;
+    status = "success";
+    subscribers.forEach((callback) => callback());
+    if (resolvePromise) resolvePromise();
+  }).catch((error) => {
+    console.error("Failed to load initial data:", error);
+    status = "error";
+  });
+  const setData = (newData) => {
+    currentData = newData;
+    status = "success";
+    subscribers.forEach((callback) => callback());
+    if (resolvePromise) resolvePromise();
+  };
+  const subscribe = (callback) => {
+    subscribers.add(callback);
+    return () => subscribers.delete(callback);
+  };
+  const getSnapshot = () => {
+    if (status === "pending") {
+      throw initialDataPromise;
+    } else if (status === "error") {
+      throw new Error("An error occurred while fetching the data.");
+    }
+    return currentData;
+  };
+  const getServerSnapshot = () => {
+    if (status === "pending") {
+      throw serverDataPromise;
+    } else if (status === "error") {
+      throw new Error("Data is not available on the server.");
+    }
+    return currentData;
+  };
+  return { getSnapshot, getServerSnapshot, setData, subscribe };
+};
+var SSRStoreContext = createContext(null);
+var SSRStoreProvider = ({ store, children }) => /* @__PURE__ */ jsx(SSRStoreContext.Provider, { value: store, children });
+var useSSRStore = () => {
+  const store = useContext(SSRStoreContext);
+  if (!store) throw new Error("useSSRStore must be used within a SSRStoreProvider");
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot);
+};
+export {
+  SSRStoreProvider,
+  createSSRStore,
+  useSSRStore
+};

package/dist/SSRServer.d.ts

@@ -0,0 +1,68 @@
+import { FastifyPluginAsync } from 'fastify';
+import { ServerResponse } from 'node:http';
+
+declare const SSRServer: FastifyPluginAsync<SSRServerOptions>;
+type ServiceRegistry = {
+    [serviceName: string]: {
+        [methodName: string]: (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    };
+};
+type RenderCallbacks = {
+    onHead: (headContent: string) => void;
+    onFinish: (initialDataResolved: unknown) => void;
+    onError: (error: unknown) => void;
+};
+type FetchConfig = {
+    url?: string;
+    options: RequestInit & {
+        params?: any;
+    };
+    serviceName?: string;
+    serviceMethod?: string;
+};
+type SSRServerOptions = {
+    clientRoot: string;
+    clientHtmlTemplate: string;
+    clientEntryClient: string;
+    clientEntryServer: string;
+    routes: Route<RouteParams>[];
+    serviceRegistry: ServiceRegistry;
+    isDebug?: boolean;
+};
+type Manifest = {
+    [key: string]: {
+        file: string;
+        src?: string;
+        isDynamicEntry?: boolean;
+        imports?: string[];
+        css?: string[];
+        assets?: string[];
+    };
+};
+type RenderModule = {
+    streamRender: (serverResponse: ServerResponse, callbacks: RenderCallbacks, initialDataPromise: Promise<Record<string, unknown>>, bootstrapModules: string) => void;
+};
+type RouteAttributes<Params = {}> = {
+    fetch: (params?: Params, options?: RequestInit & {
+        params?: Record<string, unknown>;
+    }) => Promise<{
+        options: RequestInit & {
+            params?: Record<string, unknown>;
+        };
+        serviceName?: string;
+        serviceMethod?: string;
+        url?: string;
+    }>;
+};
+type Route<Params = {}> = {
+    attributes: RouteAttributes<Params>;
+    path: string;
+};
+interface InitialRouteParams extends Record<string, unknown> {
+    serviceName?: string;
+    serviceMethod?: string;
+}
+type RouteParams = InitialRouteParams & Record<string, unknown>;
+type RoutePathsAndAttributes<Params = {}> = Omit<Route<Params>, 'element'>;
+
+export { type FetchConfig, type InitialRouteParams, type Manifest, type RenderCallbacks, type RenderModule, type Route, type RouteAttributes, type RouteParams, type RoutePathsAndAttributes, SSRServer, type SSRServerOptions, type ServiceRegistry };

package/dist/SSRServer.js

@@ -0,0 +1,395 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/fastify-plugin/lib/getPluginName.js
+var require_getPluginName = __commonJS({
+  "node_modules/fastify-plugin/lib/getPluginName.js"(exports, module) {
+    "use strict";
+    var fpStackTracePattern = /at\s{1}(?:.*\.)?plugin\s{1}.*\n\s*(.*)/;
+    var fileNamePattern = /(\w*(\.\w*)*)\..*/;
+    module.exports = function getPluginName(fn) {
+      if (fn.name.length > 0) return fn.name;
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 10;
+      try {
+        throw new Error("anonymous function");
+      } catch (e) {
+        Error.stackTraceLimit = stackTraceLimit;
+        return extractPluginName(e.stack);
+      }
+    };
+    function extractPluginName(stack) {
+      const m = stack.match(fpStackTracePattern);
+      return m ? m[1].split(/[/\\]/).slice(-1)[0].match(fileNamePattern)[1] : "anonymous";
+    }
+    module.exports.extractPluginName = extractPluginName;
+  }
+});
+
+// node_modules/fastify-plugin/lib/toCamelCase.js
+var require_toCamelCase = __commonJS({
+  "node_modules/fastify-plugin/lib/toCamelCase.js"(exports, module) {
+    "use strict";
+    module.exports = function toCamelCase(name) {
+      if (name[0] === "@") {
+        name = name.slice(1).replace("/", "-");
+      }
+      const newName = name.replace(/-(.)/g, function(match2, g1) {
+        return g1.toUpperCase();
+      });
+      return newName;
+    };
+  }
+});
+
+// node_modules/fastify-plugin/plugin.js
+var require_plugin = __commonJS({
+  "node_modules/fastify-plugin/plugin.js"(exports, module) {
+    "use strict";
+    var getPluginName = require_getPluginName();
+    var toCamelCase = require_toCamelCase();
+    var count = 0;
+    function plugin(fn, options = {}) {
+      let autoName = false;
+      if (typeof fn.default !== "undefined") {
+        fn = fn.default;
+      }
+      if (typeof fn !== "function") {
+        throw new TypeError(
+          `fastify-plugin expects a function, instead got a '${typeof fn}'`
+        );
+      }
+      if (typeof options === "string") {
+        options = {
+          fastify: options
+        };
+      }
+      if (typeof options !== "object" || Array.isArray(options) || options === null) {
+        throw new TypeError("The options object should be an object");
+      }
+      if (options.fastify !== void 0 && typeof options.fastify !== "string") {
+        throw new TypeError(`fastify-plugin expects a version string, instead got '${typeof options.fastify}'`);
+      }
+      if (!options.name) {
+        autoName = true;
+        options.name = getPluginName(fn) + "-auto-" + count++;
+      }
+      fn[Symbol.for("skip-override")] = options.encapsulate !== true;
+      fn[Symbol.for("fastify.display-name")] = options.name;
+      fn[Symbol.for("plugin-meta")] = options;
+      if (!fn.default) {
+        fn.default = fn;
+      }
+      const camelCase = toCamelCase(options.name);
+      if (!autoName && !fn[camelCase]) {
+        fn[camelCase] = fn;
+      }
+      return fn;
+    }
+    module.exports = plugin;
+    module.exports.default = plugin;
+    module.exports.fastifyPlugin = plugin;
+  }
+});
+
+// src/SSRServer.ts
+var import_fastify_plugin = __toESM(require_plugin(), 1);
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createViteRuntime } from "vite";
+
+// src/utils/index.ts
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { match } from "path-to-regexp";
+var isDevelopment = process.env.NODE_ENV === "development";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = join(dirname(__filename), !isDevelopment ? "./" : "..");
+var CSS_LANGS_RE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+async function collectStyle(server, entries) {
+  const urls = await collectStyleUrls(server, entries);
+  const codes = await Promise.all(
+    urls.map(async (url) => {
+      const res = await server.transformRequest(url + "?direct");
+      return [`/* [collectStyle] ${url} */`, res?.code];
+    })
+  );
+  return codes.flat().filter(Boolean).join("\n\n");
+}
+async function collectStyleUrls(server, entries) {
+  const visited = /* @__PURE__ */ new Set();
+  async function traverse(url) {
+    const [, id] = await server.moduleGraph.resolveUrl(url);
+    if (visited.has(id)) return;
+    visited.add(id);
+    const mod = server.moduleGraph.getModuleById(id);
+    if (!mod) return;
+    await Promise.all([...mod.importedModules].map((childMod) => traverse(childMod.url)));
+  }
+  await Promise.all(entries.map((e) => server.transformRequest(e)));
+  await Promise.all(entries.map((url) => traverse(url)));
+  return [...visited].filter((url) => url.match(CSS_LANGS_RE));
+}
+function renderPreloadLinks(modules, manifest) {
+  const seen = /* @__PURE__ */ new Set();
+  let links = "";
+  modules.forEach((id) => {
+    const files = manifest[id];
+    if (files) {
+      files.forEach((file) => {
+        if (!seen.has(file)) {
+          seen.add(file);
+          links += renderPreloadLink(file);
+        }
+      });
+    }
+  });
+  return links;
+}
+function renderPreloadLink(file) {
+  const fileType = file.match(/\.(js|css|woff2?|gif|jpe?g|png|svg)$/)?.[1];
+  if (!fileType) return "";
+  switch (fileType) {
+    case "js":
+      return `<link rel="modulepreload" href="${file}">`;
+    case "css":
+      return `<link rel="stylesheet" href="${file}">`;
+    case "woff":
+    case "woff2":
+      return `<link rel="preload" href="${file}" as="font" type="font/${fileType}" crossorigin>`;
+    case "gif":
+    case "jpeg":
+    case "jpg":
+    case "png":
+      return `<link rel="preload" href="${file}" as="image" type="image/${fileType}">`;
+    case "svg":
+      return `<link rel="preload" href="${file}" as="image" type="image/svg+xml">`;
+    default:
+      return "";
+  }
+}
+var callServiceMethod = async (serviceRegistry, serviceName, serviceMethod, params) => {
+  const service = serviceRegistry[serviceName];
+  if (service && typeof service[serviceMethod] === "function") {
+    const method = service[serviceMethod];
+    const data = await method(params);
+    if (typeof data !== "object" || data === null)
+      throw new Error(`Expected object response from service method ${serviceMethod} on ${serviceName}, but got ${typeof data}`);
+    return data;
+  }
+  throw new Error(`Service method ${serviceMethod} does not exist on ${serviceName}`);
+};
+var fetchData = async ({ url, options }) => {
+  if (url) {
+    const response = await fetch(url, options);
+    if (!response.ok) throw new Error(`Failed to fetch data from ${url}`);
+    const data = await response.json();
+    if (typeof data !== "object" || data === null) throw new Error(`Expected object response from ${url}, but got ${typeof data}`);
+    return data;
+  }
+  throw new Error("URL must be provided to fetch data");
+};
+var matchRoute = (url, renderRoutes) => {
+  for (const route of renderRoutes) {
+    const matcher = match(route.path, {
+      decode: decodeURIComponent
+    });
+    const matched = matcher(url);
+    if (matched) return { route, params: matched.params };
+  }
+  return null;
+};
+var getCssLinks = (manifest) => {
+  const links = [];
+  for (const value of Object.values(manifest)) {
+    if (value.css && value.css.length > 0) {
+      value.css.forEach((cssFile) => {
+        links.push(`<link rel="preload stylesheet" as="style" type="text/css" href="/${cssFile}">`);
+      });
+    }
+  }
+  return links.join("");
+};
+var overrideCSSHMRConsoleError = () => {
+  const originalConsoleError = console.error;
+  console.error = function(message, ...optionalParams) {
+    if (typeof message === "string" && message.includes("css hmr is not supported in runtime mode")) return;
+    originalConsoleError.apply(console, [message, ...optionalParams]);
+  };
+};
+
+// src/SSRServer.ts
+var SSRServer = (0, import_fastify_plugin.default)(
+  async (app, opts) => {
+    const { clientRoot, clientHtmlTemplate, clientEntryClient, clientEntryServer, routes, serviceRegistry, isDebug } = opts;
+    const templateHtmlPath = path.join(clientRoot, clientHtmlTemplate);
+    const templateHtml = !isDevelopment ? await fs.readFile(templateHtmlPath, "utf-8") : await fs.readFile(path.join(clientRoot, clientHtmlTemplate), "utf-8");
+    const ssrManifestPath = path.join(clientRoot, ".vite/ssr-manifest.json");
+    const ssrManifest = !isDevelopment ? JSON.parse(await fs.readFile(ssrManifestPath, "utf-8")) : void 0;
+    const manifestPath = path.join(clientRoot, ".vite/manifest.json");
+    const manifest = !isDevelopment ? JSON.parse(await fs.readFile(manifestPath, "utf-8")) : void 0;
+    const bootstrapModules = isDevelopment ? `/${clientEntryClient}.tsx` : `/${manifest[`${clientEntryClient}.tsx`].file}`;
+    const preloadLinks = !isDevelopment ? renderPreloadLinks(Object.keys(ssrManifest), ssrManifest) : void 0;
+    const cssLinks = !isDevelopment ? getCssLinks(manifest) : void 0;
+    let renderModule;
+    let styles;
+    let template = templateHtml;
+    let viteDevServer;
+    let viteRuntime;
+    if (isDevelopment) {
+      const { createServer } = await import("vite");
+      viteDevServer = await createServer({
+        appType: "custom",
+        mode: "development",
+        plugins: [
+          ...isDebug ? [
+            {
+              name: "taujs-ssr-server-debug-logging",
+              configureServer(server) {
+                console.log("\u03C4js debug ssr server started.");
+                server.middlewares.use((req, res, next) => {
+                  console.log(`rx: ${req.url}`);
+                  res.on("finish", () => {
+                    console.log(`cx: ${req.url}`);
+                  });
+                  next();
+                });
+              }
+            }
+          ] : []
+        ],
+        resolve: {
+          alias: {
+            "@client": path.resolve(clientRoot),
+            "@server": path.resolve(__dirname),
+            "@shared": path.resolve(__dirname, "../shared")
+          }
+        },
+        root: clientRoot,
+        server: {
+          middlewareMode: true,
+          hmr: {
+            port: 5174
+          }
+        }
+      });
+      viteRuntime = await createViteRuntime(viteDevServer);
+      overrideCSSHMRConsoleError();
+      void app.addHook("onRequest", async (request, reply) => {
+        await new Promise((resolve) => {
+          viteDevServer.middlewares(request.raw, reply.raw, () => {
+            if (!reply.sent) resolve();
+          });
+        });
+      });
+    } else {
+      renderModule = await import(path.join(clientRoot, `${clientEntryServer}.js`));
+      void await app.register(import("@fastify/static"), {
+        index: false,
+        root: path.resolve(clientRoot),
+        wildcard: false
+      });
+    }
+    void app.get("/*", async (req, reply) => {
+      try {
+        const url = req.url ? new URL(req.url, `http://${req.headers.host}`).pathname : "/";
+        const matchedRoute = matchRoute(url, routes);
+        if (!matchedRoute) {
+          reply.callNotFound();
+          return;
+        }
+        if (isDevelopment) {
+          template = await viteDevServer.transformIndexHtml(url, template);
+          renderModule = await viteRuntime.executeEntrypoint(path.join(clientRoot, `${clientEntryServer}.tsx`));
+          styles = await collectStyle(viteDevServer, [`${clientRoot}/${clientEntryServer}.tsx`]);
+          template = template.replace("</head>", `<style type="text/css">${styles}</style></head>`);
+        }
+        const { streamRender } = renderModule;
+        const { route, params } = matchedRoute;
+        const { attributes } = route;
+        const [beforeBody = "", afterBody] = template.split("<!--ssr-html-->");
+        const [beforeHead, afterHead] = beforeBody.split("<!--ssr-head-->");
+        const initialDataPromise = attributes && typeof attributes.fetch === "function" ? attributes.fetch(params, {
+          headers: { "Content-Type": "application/json" },
+          params
+        }).then((data) => {
+          if (data.serviceName && data.serviceMethod)
+            return callServiceMethod(serviceRegistry, data.serviceName, data.serviceMethod, data.options.params ?? {});
+          return fetchData(data);
+        }).catch((error) => {
+          console.error("Error fetching initial data:", error);
+          return {};
+        }) : Promise.resolve({});
+        reply.raw.writeHead(200, { "Content-Type": "text/html" });
+        reply.raw.write(beforeHead);
+        streamRender(
+          reply.raw,
+          {
+            onHead: (headContent) => {
+              let fullHeadContent = headContent;
+              if (ssrManifest) fullHeadContent += preloadLinks;
+              if (manifest) fullHeadContent += cssLinks;
+              reply.raw.write(`${fullHeadContent}${afterHead}`);
+            },
+            onFinish: async (initialDataResolved) => {
+              reply.raw.write(`<script>window.__INITIAL_DATA__ = ${JSON.stringify(initialDataResolved).replace(/</g, "\\u003c")}</script>`);
+              reply.raw.write(afterBody);
+              reply.raw.end();
+            },
+            onError: (error) => {
+              console.error("Critical rendering error:", error);
+              if (!reply.raw.headersSent) reply.raw.writeHead(500, { "Content-Type": "text/plain" });
+              reply.raw.end("Internal Server Error");
+            }
+          },
+          initialDataPromise,
+          bootstrapModules
+        );
+      } catch (error) {
+        console.error("Error setting up SSR stream:", error);
+        if (!reply.raw.headersSent) reply.raw.writeHead(500, { "Content-Type": "text/plain" });
+        reply.raw.end("Internal Server Error");
+      }
+    });
+    void app.setNotFoundHandler(async (req, reply) => {
+      if (/\.\w+$/.test(req.raw.url ?? "")) return reply.callNotFound();
+      try {
+        let template2 = templateHtml;
+        template2 = template2.replace("<!--ssr-head-->", "").replace("<!--ssr-html-->", "");
+        if (!isDevelopment) template2 = template2.replace("</head>", `${getCssLinks(manifest)}</head>`);
+        template2 = template2.replace("</body>", `<script type="module" src="${bootstrapModules}" async=""></script></body>`);
+        reply.status(200).type("text/html").send(template2);
+      } catch (error) {
+        console.error("Failed to serve clientHtmlTemplate:", error);
+        reply.status(500).send("Internal Server Error");
+      }
+    });
+  },
+  { name: "taujs-ssr-server" }
+);
+export {
+  SSRServer
+};

package/package.json

@@ -0,0 +1,85 @@
+{
+  "author": "Aoede <taujs@aoede.uk.net> (https://www.aoede.uk.net)",
+  "bugs": {
+    "url": "https://github.com/aoede3/taujs-server/issues"
+  },
+  "description": "taujs | τjs",
+  "homepage": "https://github.com/aoede3/taujs-server",
+  "keywords": [
+    "fastify",
+    "typescript",
+    "esm",
+    "vite",
+    "streaming",
+    "react",
+    "ssr"
+  ],
+  "license": "MIT",
+  "name": "@taujs/server",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aoede3/taujs-server.git"
+  },
+  "version": "0.0.1",
+  "exports": {
+    ".": {
+      "import": "./dist/SSRServer.js",
+      "types": "./dist/SSRServer.d.ts"
+    },
+    "./data-store": {
+      "import": "./dist/SSRDataStore.js",
+      "types": "./dist/SSRDataStore.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/SSRServer.js",
+  "types": "./dist/SSRServer.d.ts",
+  "typesVersions": {
+    "*": {
+      "data-store": [
+        "./dist/SSRDataStore.d.ts"
+      ]
+    }
+  },
+  "type": "module",
+  "dependencies": {
+    "@fastify/static": "^7.0.4",
+    "path-to-regexp": "^7.0.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.15.4",
+    "@babel/preset-typescript": "^7.24.7",
+    "@changesets/cli": "^2.27.7",
+    "@types/node": "^20.14.9",
+    "@types/react": "^18.3.3",
+    "fastify": "^4.28.0",
+    "prettier": "^3.3.3",
+    "tsup": "^8.2.4",
+    "vite": "^5.4.2",
+    "vitest": "^2.0.5"
+  },
+  "peerDependencies": {
+    "@types/node": "^20.14.9",
+    "@types/react": "^18.3.3",
+    "@vitejs/plugin-react": "^4.3.1",
+    "fastify": "^4.28.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "typescript": "^5.5.4",
+    "vite": "^5.4.2"
+  },
+  "scripts": {
+    "build": "tsup",
+    "ci": "npm run build && npm run check-format && npm run check-exports && npm run lint",
+    "lint": "tsc",
+    "test": "vitest run",
+    "format": "prettier --write .",
+    "check-format": "prettier --check .",
+    "check-exports": "attw --pack . --ignore-rules=cjs-resolves-to-esm",
+    "prepublishOnly": "npm run ci",
+    "local-release": "npm run ci && changeset version && changeset publish"
+  }
+}