flamefront 0.1.3 → 0.1.4

package/README.md

@@ -76,6 +76,7 @@ Licensed under [MIT](./LICENSE.md).
 
 - [How Flamefront fits](./docs/index.md)
 - [Route rendering and data](./docs/routes.md)
+- [Render the whole document](./docs/document.md)
 - [Forms and mutations](./docs/forms-and-mutations.md)
 - [Build and deployment](./docs/deployment.md)
 - [Migrating an existing app](./docs/brownfield-migration.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flamefront",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "private": false,
   "description": "Typed centralized route manifests for Octane.",
   "license": "MIT",
@@ -23,6 +23,7 @@
     ".": "./src/index.ts",
     "./action-client": "./src/action-client.ts",
     "./entry": "./src/entry.ts",
+    "./document": "./src/document.tsx",
     "./fetch": "./src/fetch.ts",
     "./fragment": "./src/fragment.tsx",
     "./octane": "./src/octane.tsx",

package/src/document-assets.ts

@@ -0,0 +1,106 @@
+/** Internal, serializable description of a framework-owned document asset. */
+export interface DocumentAsset {
+  readonly tag: "link" | "style" | "script"
+  readonly attributes: Readonly<Record<string, string>>
+  readonly content?: string
+}
+
+export interface DocumentAssets {
+  readonly head: readonly DocumentAsset[]
+  readonly scripts: readonly DocumentAsset[]
+}
+
+export const documentAssetAttribute = "data-flamefront-asset"
+
+function decodeAttribute(value: string): string {
+  return value.replace(
+    /&(#x[\da-f]+|#\d+|amp|quot|apos|lt|gt);/gi,
+    (entity, name: string) => {
+      if (name[0] === "#") {
+        const code =
+          name[1].toLowerCase() === "x"
+            ? parseInt(name.slice(2), 16)
+            : Number(name.slice(1))
+
+        return code > 0 && code <= 0x10ffff
+          ? String.fromCodePoint(code)
+          : "\ufffd"
+      }
+
+      return (
+        (
+          { amp: "&", quot: '"', apos: "'", lt: "<", gt: ">" } as Record<
+            string,
+            string
+          >
+        )[name.toLowerCase()] ?? entity
+      )
+    },
+  )
+}
+
+/** Extract only asset tags; document metadata belongs to the document component. */
+export function documentAssets(
+  template: string,
+  hydrationScript: string,
+): DocumentAssets {
+  const head: DocumentAsset[] = []
+  const scripts: DocumentAsset[] = []
+  // Consume comments and raw-text elements as units so their contents cannot
+  // masquerade as asset tags. Quoted attribute values may contain angle brackets.
+  const tags =
+    /<!--[\s\S]*?-->|<(script|style|title|textarea|template|link)\b((?:[^>"']|"[^"]*"|'[^']*')*)>(?:([\s\S]*?)<\/\1\s*>)?/gi
+
+  for (const match of `${template}${hydrationScript}`.matchAll(tags)) {
+    const tag = match[1]?.toLowerCase()
+
+    if (tag !== "script" && tag !== "style" && tag !== "link") {
+      continue
+    }
+
+    const attributes: Record<string, string> = {}
+
+    for (const attribute of match[2].matchAll(
+      /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g,
+    )) {
+      attributes[attribute[1].toLowerCase()] = decodeAttribute(
+        attribute[2] ?? attribute[3] ?? attribute[4] ?? "",
+      )
+    }
+
+    attributes[documentAssetAttribute] = tag === "script" ? "scripts" : "head"
+    const asset: DocumentAsset = {
+      tag,
+      attributes,
+      ...(tag === "link" ? {} : { content: match[3] ?? "" }),
+    }
+
+    ;(tag === "script" ? scripts : head).push(asset)
+  }
+
+  return { head, scripts }
+}
+
+/** Snapshot server assets before hydration; no scripts are re-executed. */
+export function readDocumentAssets(document: Document): DocumentAssets {
+  const read = (slot: string): DocumentAsset[] =>
+    Array.from(
+      document.querySelectorAll(`[${documentAssetAttribute}="${slot}"]`),
+      (element) => ({
+        tag: element.localName as DocumentAsset["tag"],
+        attributes: Object.fromEntries(
+          Array.from(element.attributes, ({ name, value }) => [
+            name,
+            name === "nonce"
+              ? ((element as HTMLElement).nonce ?? value)
+              : value,
+          ]),
+        ),
+        ...(element.localName === "link"
+          ? {}
+          : { content: element.textContent ?? "" }),
+      }),
+    )
+
+  return { head: read("head"), scripts: read("scripts") }
+}

package/src/document-template.ts

@@ -0,0 +1,22 @@
+import { readFile } from "node:fs/promises"
+import { resolve } from "node:path"
+
+/** Vite still processes an HTML entry to discover and hash client assets. */
+export async function readProjectTemplate(
+  root: string,
+  hasDocument: boolean,
+): Promise<string> {
+  try {
+    return await readFile(resolve(root, "index.html"), "utf8")
+  } catch (error) {
+    if (!hasDocument || (error as NodeJS.ErrnoException).code !== "ENOENT") {
+      throw error
+    }
+
+    return '<!doctype html><html><head></head><body><script type="module" src="/src/main.ts"></script></body></html>'
+  }
+}
+
+// Vite's evaluated SSR modules do not share the plugin's module cache. Keep
+// development-only callbacks scoped by project, and release them on close.
+export const devTemplateLoadersKey = "flamefront:dev-template-loaders"

package/src/document.tsx

@@ -0,0 +1,68 @@
+import {
+  createContext,
+  createElement,
+  useContext,
+  type ReactNode,
+} from "octane"
+import type { DocumentAsset, DocumentAssets } from "./document-assets.ts"
+
+/** Props supplied to the optional app document component. */
+export interface DocumentProps {
+  /** The persistent shell and matched route, already inside router context. */
+  readonly children?: ReactNode
+}
+
+/** @internal Framework assets shared by server rendering and hydration. */
+export const documentAssetsContext = createContext<DocumentAssets | null>(null)
+
+function renderAssets(assets: readonly DocumentAsset[]) {
+  return assets.map(({ tag, attributes, content }) =>
+    createElement(tag, {
+      ...attributes,
+      ...(content === undefined
+        ? {}
+        : { dangerouslySetInnerHTML: { __html: content } }),
+    }),
+  )
+}
+
+/** Render Vite styles and asset links. Place once inside the document's head. */
+export function Head() {
+  const assets = useContext(documentAssetsContext)
+
+  if (!assets) {
+    throw new Error("Head must be rendered inside a Flamefront document.")
+  }
+
+  return renderAssets(assets.head)
+}
+
+/** Render hydration data and client scripts. Place once at the end of body. */
+export function Scripts() {
+  const assets = useContext(documentAssetsContext)
+
+  if (!assets) {
+    throw new Error("Scripts must be rendered inside a Flamefront document.")
+  }
+
+  return renderAssets(assets.scripts)
+}
+
+/** @internal Keep the document outside independently hydrated shell boundaries. */
+export function createDocumentShell(
+  Document: (props: DocumentProps) => unknown,
+  Shell: (props: Record<string, unknown>) => unknown,
+) {
+  return (props: Record<string, unknown>) => {
+    const assets = useContext(documentAssetsContext)
+
+    // Fragment renders use a separate router root and return only the shell.
+    return assets ? (
+      <Document>
+        <Shell {...props} />
+      </Document>
+    ) : (
+      <Shell {...props} />
+    )
+  }
+}

package/src/index.ts

@@ -463,6 +463,8 @@ export type RouteDestination<Path extends string = RoutePath> =
     }
 
 export interface AppDefinition<T extends RouteDefinition = RouteDefinition> {
+  /** Optional project-root module ID for the component owning html, head, and body. */
+  readonly document?: string
   /** Octane/Vite project-root module ID for the persistent app shell. */
   readonly shell: string
   /** Hydration policy for the persistent shell region. */
@@ -1130,6 +1132,7 @@ function matchRoutes<T extends RouteDefinition>(
 /** Normalize and validate the application's explicit route graph. */
 export function defineApp<
   const T extends {
+    readonly document?: string
     readonly shell: string
     readonly routes: readonly RouteConfig[]
     readonly shellHydration?: HydrationMode
@@ -1149,6 +1152,9 @@ export function defineApp<
   }
 
   assertString(options.shell, "app shell entry")
+  if (options.document !== undefined) {
+    assertString(options.document, "app document entry")
+  }
 
   const hydrationDefaults = normalizeHydrationDefaults(
     options.hydrationDefaults,

package/src/octane-client-core.ts

@@ -3,7 +3,7 @@ import type { RouterDocument, RouterDocumentProps } from "./octane.tsx"
 import { shellIdentifierPrefix } from "./identifier-prefix.ts"
 
 export type OctaneClientApp<Route extends RouteDefinition = RouteDefinition> =
-  Pick<AppDefinition<Route>, "match" | "prefetch">
+  Pick<AppDefinition<Route>, "match" | "prefetch" | "document">
 
 export interface OctaneClientRouter {
   readonly state: { readonly initialized: boolean }
@@ -14,10 +14,10 @@ export interface OctaneClientRouter {
 
 export interface StartOctaneClientOptions<
   Route extends RouteDefinition = RouteDefinition,
-  Container = Element,
+  Container = Element | Document,
 > {
   readonly app: OctaneClientApp<Route>
-  /** Defaults to the current document's `#root` element. */
+  /** Defaults to `document` for app documents, otherwise the `#root` element. */
   readonly root?: Container | null
   /** Use the same override in `createOctaneDocuments` on the server. */
   readonly routerDocument?: RouterDocument
@@ -39,6 +39,7 @@ export interface OctaneClientRuntime<
   readonly pathname: string
   readonly defaultRoot: Container | null
   readonly routerDocument: RouterDocument
+  readonly documentAssets?: RouterDocumentProps["documentAssets"]
   consumeHydrationData(): HydrationData
   createRoutePrefetcher(app: OctaneClientApp<Route>): Prefetch
   createClientRouter(options: {
@@ -121,14 +122,21 @@ export async function startOctaneClientWithRuntime<
     hydrationData,
     prefetch: runtime.createRoutePrefetcher(options.app),
   })
-  const shouldHydrate = routeMatch.data.render !== "client"
+  const shouldHydrate =
+    Boolean(options.app.document) || routeMatch.data.render !== "client"
 
   if (shouldHydrate) {
     await waitForRouterInitialization(router)
   }
 
   const routerDocument = options.routerDocument ?? runtime.routerDocument
-  const props: RouterDocumentProps = { router, context: undefined }
+  const props: RouterDocumentProps = {
+    router,
+    context: undefined,
+    ...(runtime.documentAssets
+      ? { documentAssets: runtime.documentAssets }
+      : {}),
+  }
   const clientRoot = shouldHydrate
     ? runtime.hydrateRoot(root, routerDocument, props, {
         identifierPrefix: shellIdentifierPrefix,

package/src/octane-client.ts

@@ -2,6 +2,7 @@ import type { DataRouter } from "@octanejs/remix-router"
 import { createRoot, hydrateRoot, type ComponentBody, type Root } from "octane"
 import type { RouteDefinition } from "./index.ts"
 import type { RouterDocumentProps } from "./octane.tsx"
+import { readDocumentAssets } from "./document-assets.ts"
 import {
   startOctaneClientWithRuntime,
   type StartOctaneClientOptions,
@@ -26,9 +27,15 @@ export function startOctaneClient<Route extends RouteDefinition>(
 ): Promise<StartedOctaneClient<DataRouter, Root>> {
   return startOctaneClientWithRuntime(options, {
     pathname: window.location.pathname,
-    defaultRoot: document.getElementById("root"),
+    defaultRoot: options.app.document
+      ? document
+      : document.getElementById("root"),
+    ...(options.app.document
+      ? { documentAssets: readDocumentAssets(document) }
+      : {}),
     routerDocument: RouterDocument,
-    consumeHydrationData: consumeStaticRouterHydrationData,
+    consumeHydrationData: () =>
+      consumeStaticRouterHydrationData(Boolean(options.app.document)),
     createRoutePrefetcher,
     createClientRouter,
     renderRoot(root, component, props, options) {

package/src/octane-router-document.ts

@@ -1,6 +1,7 @@
 import { RouterProvider } from "@octanejs/remix-router/dom"
 import { createElement } from "octane"
 import { routeOutletHtmlContext } from "./fragment.tsx"
+import { documentAssetsContext } from "./document.tsx"
 import type {
   RouterDocument as RouterDocumentComponent,
   RouterDocumentProps,
@@ -14,9 +15,17 @@ export const RouterDocument: RouterDocumentComponent = (
     readonly router: unknown
   }) => unknown
 
-  return createElement(
+  const content = createElement(
     routeOutletHtmlContext.Provider,
     { value: props.outletHtml ?? null },
     createElement(Router, { router: props.router }),
   )
+
+  return props.documentAssets
+    ? createElement(
+        documentAssetsContext.Provider,
+        { value: props.documentAssets },
+        content,
+      )
+    : content
 }

package/src/octane.tsx

@@ -4,6 +4,7 @@ import type {
   RouteDefinition,
   RouteParams,
 } from "./index.ts"
+import { documentAssets, type DocumentAssets } from "./document-assets.ts"
 import type {
   DocumentMode,
   RouteRuntime,
@@ -28,6 +29,7 @@ import {
 export type { DocumentMode, RenderedDocument } from "./server.ts"
 
 export interface RouterDocumentProps {
+  readonly documentAssets?: DocumentAssets
   readonly router: unknown
   readonly context: unknown
   /** Server-only markup for the independently-owned routed outlet. */
@@ -231,6 +233,28 @@ export function composeDefaultDocument(
     .replace("</body>", `${hydrationScript}</body>`)
 }
 
+function composeComponentDocument(body: string, css: string): string {
+  if (
+    !/<html\b/i.test(body) ||
+    !body.includes("</head>") ||
+    !body.includes("</body>")
+  ) {
+    throw new Error(
+      "The app document must render html, head, and body elements.",
+    )
+  }
+
+  const scripts = body.split(`id="${staticRouterHydrationScriptId}"`).length - 1
+
+  if (scripts !== 1) {
+    throw new Error(
+      "The app document must render Scripts exactly once inside body.",
+    )
+  }
+
+  return `<!doctype html>${body.replace(/^\s*<!doctype html>/i, "").replace("</head>", `${css}</head>`)}`
+}
+
 async function loadDefaultRouter(): Promise<DocumentRouter> {
   const module = await import("./remix-router.ts")
 
@@ -534,6 +558,7 @@ export function createOctaneDocuments<
     mode: DocumentMode,
     route: RouteDefinition | null,
     renderOutlet = false,
+    template = "",
   ): Promise<{
     readonly router: DocumentRouter
     readonly dataRouter: unknown
@@ -586,6 +611,14 @@ export function createOctaneDocuments<
     const documentProps: RouterDocumentProps = {
       router: dataRouter,
       context,
+      ...(options.app.document
+        ? {
+            documentAssets: documentAssets(
+              template,
+              staticRouterHydrationScript(context),
+            ),
+          }
+        : {}),
       ...(outlet ? { outletHtml: outlet.html } : {}),
     }
     const rendered = renderer.renderToString(routerDocument, documentProps, {
@@ -620,6 +653,7 @@ export function createOctaneDocuments<
       mode,
       route,
       true,
+      template,
     )
     const status = staticContext.statusCode ?? 200
     const compositionContext: DocumentCompositionContext<Route> = {
@@ -639,12 +673,14 @@ export function createOctaneDocuments<
     }
     const html = await (options.composeDocument
       ? options.composeDocument(parts, compositionContext)
-      : composeDefaultDocument(
-          parts.template,
-          parts.body,
-          parts.css,
-          parts.hydrationScript,
-        ))
+      : options.app.document
+        ? composeComponentDocument(parts.body, parts.css)
+        : composeDefaultDocument(
+            parts.template,
+            parts.body,
+            parts.css,
+            parts.hydrationScript,
+          ))
 
     const headers = actionResponseHeaders(staticContext)
 

package/src/prerender-artifacts.ts

@@ -138,10 +138,26 @@ export function assembleStaticRouteArtifact(
     return null
   }
 
-  let html = artifact.html
+  let index = 0
+  let valid = true
+  const html = artifact.html.replace(
+    /((?:src|href)=)(['"])(\/assets\/[^'"]+)\2/g,
+    (match, attribute: string, quote: string, asset: string) => {
+      if (index >= previous.length) {
+        return match
+      }
+
+      if (asset !== previous[index]) {
+        valid = false
+        return match
+      }
 
-  for (let index = 0; index < previous.length; index += 1) {
-    html = html.replaceAll(previous[index], current.assets[index])
+      return `${attribute}${quote}${current.assets[index++]}${quote}`
+    },
+  )
+
+  if (!valid || index !== previous.length) {
+    return null
   }
 
   return { ...artifact, html, template: current }

package/src/prerender.ts

@@ -296,6 +296,7 @@ export async function renderingFingerprint(
 ): Promise<string> {
   const entries = [
     app.shell,
+    ...(app.document ? [app.document] : []),
     ...(layoutEntries(app.routeTree, route) ?? []),
     route.entry,
     "/src/entry-server.ts",
@@ -335,6 +336,7 @@ export async function renderingFingerprint(
       hydration: route.hydration,
     },
     shell: app.shell,
+    document: app.document,
     shellHydration: app.shellHydration,
     routing: app.routing,
     compiler: stableValue(options),

package/src/remix-router.ts

@@ -40,15 +40,20 @@ export type {
 export const staticRouterHydrationScriptId =
   "flamefront-static-router-hydration"
 
-/** Read and remove the hydration payload emitted by the server document adapter. */
-export function consumeStaticRouterHydrationData(): HydrationState | undefined {
+/** Read hydration data; preserve its script when the document owns that node. */
+export function consumeStaticRouterHydrationData(
+  preserveScript = false,
+): HydrationState | undefined {
   const data = (
     window as typeof window & {
       __staticRouterHydrationData?: unknown
     }
   ).__staticRouterHydrationData
 
-  document.getElementById(staticRouterHydrationScriptId)?.remove()
+  if (!preserveScript) {
+    document.getElementById(staticRouterHydrationScriptId)?.remove()
+  }
+
   return data as HydrationState | undefined
 }
 

package/src/vite.ts

@@ -1,4 +1,9 @@
 import fs from "node:fs"
+import type { ViteDevServer } from "vite"
+import {
+  readProjectTemplate,
+  devTemplateLoadersKey,
+} from "./document-template.ts"
 import path from "node:path"
 import { pathToFileURL } from "node:url"
 import { compile as compileOctane } from "octane/compiler"
@@ -319,7 +324,7 @@ function generateConfigs(
 export function generateRemixRoutes(
   app: Pick<
     AppDefinition,
-    "shell" | "shellHydration" | "routeTree" | "routing"
+    "shell" | "shellHydration" | "routeTree" | "routing" | "document"
   >,
 ): string {
   const rootId = "flamefront:shell:root"
@@ -328,8 +333,15 @@ export function generateRemixRoutes(
     app.shell,
     app.shellHydration,
   )
-
-  return `// Generated by Flamefront.\nimport Shell from ${quote(app.shell)};\nimport { RouterDocument } from 'flamefront/octane/router-document';\nimport { createRouteBoundary, createRouteFragmentRoute } from 'flamefront/fragment';\nimport { loadRouteData, loadRouteFragment } from 'flamefront/remix-router/data';\nimport { submitRouteAction } from 'flamefront/remix-router/data';\n\nexport { RouterDocument };\nexport const routing = ${JSON.stringify(app.routing)};\nexport const routeMetadata = ${JSON.stringify(routeMetadata)};\n\nexport const routes = [\n\t{\n\t\tid: ${quote(rootId)},\n\t\tComponent: createRouteBoundary(Shell, ${JSON.stringify(routeMetadata[0])}),\n\t\thandle: { flamefront: ${JSON.stringify(routeMetadata[0])} },\n\t\tchildren: [\n${generateConfigs(app.routeTree, app.routing, 3)}\n\t\t],\n\t},\n];\n\n${generateRoutePreloaders(app.routeTree)}`
+  const documentImport = app.document
+    ? `import Document from ${quote(app.document)};\nimport { createDocumentShell } from 'flamefront/document';\n`
+    : ""
+  const shellComponent = `createRouteBoundary(Shell, ${JSON.stringify(routeMetadata[0])})`
+  const rootComponent = app.document
+    ? `createDocumentShell(Document, ${shellComponent})`
+    : shellComponent
+
+  return `// Generated by Flamefront.\n${documentImport}import Shell from ${quote(app.shell)};\nimport { RouterDocument } from 'flamefront/octane/router-document';\nimport { createRouteBoundary, createRouteFragmentRoute } from 'flamefront/fragment';\nimport { loadRouteData, loadRouteFragment } from 'flamefront/remix-router/data';\nimport { submitRouteAction } from 'flamefront/remix-router/data';\n\nexport { RouterDocument };\nexport const routing = ${JSON.stringify(app.routing)};\nexport const routeMetadata = ${JSON.stringify(routeMetadata)};\n\nexport const routes = [\n\t{\n\t\tid: ${quote(rootId)},\n\t\tComponent: ${rootComponent},\n\t\thandle: { flamefront: ${JSON.stringify(routeMetadata[0])} },\n\t\tchildren: [\n${generateConfigs(app.routeTree, app.routing, 3)}\n\t\t],\n\t},\n];\n\n${generateRoutePreloaders(app.routeTree)}`
 }
 
 /** Generate the server-only route-module importer used by loader endpoints. */
@@ -725,6 +737,8 @@ export function flamefront(options: FlamefrontOptions = {}) {
   })
   let root = process.cwd()
   let serverBuild = false
+  let devServer: ViteDevServer | undefined
+  let releaseDevTemplate: (() => void) | undefined
   let appPromise: Promise<AppDefinition> | undefined
   let manifestRevision = 0
   let manifestGlobDirectories: readonly string[] = []
@@ -773,6 +787,29 @@ export function flamefront(options: FlamefrontOptions = {}) {
     name: "flamefront:framework-modules",
     enforce: "pre" as const,
     configResolved: configureRoot,
+    configureServer(server: ViteDevServer) {
+      devServer = server
+      const registry = globalThis as typeof globalThis & {
+        [key: symbol]: Map<string, (url: string) => Promise<string>> | undefined
+      }
+      const key = Symbol.for(devTemplateLoadersKey)
+      const loaders = (registry[key] ??= new Map())
+      const loadTemplate = async (url: string) =>
+        server.transformIndexHtml(
+          url,
+          await readProjectTemplate(root, Boolean((await loadApp()).document)),
+        )
+
+      loaders.set(root, loadTemplate)
+      releaseDevTemplate = () => {
+        if (loaders.get(root) === loadTemplate) {
+          loaders.delete(root)
+        }
+      }
+    },
+    closeBundle() {
+      releaseDevTemplate?.()
+    },
     async buildStart() {
       await generateTypes()
     },
@@ -881,6 +918,14 @@ export function flamefront(options: FlamefrontOptions = {}) {
       importer?: string,
       resolveOptions: ResolveOptions = {},
     ) {
+      if (
+        id === path.resolve(root, "index.html") &&
+        !fs.existsSync(id) &&
+        (await loadApp()).document
+      ) {
+        return id
+      }
+
       if (id === remixRoutesId) {
         return resolvedRemixRoutesId
       }
@@ -979,6 +1024,14 @@ export function flamefront(options: FlamefrontOptions = {}) {
       )
     },
     async load(id: string) {
+      if (
+        id === path.resolve(root, "index.html") &&
+        !fs.existsSync(id) &&
+        (await loadApp()).document
+      ) {
+        return readProjectTemplate(root, true)
+      }
+
       if (id === resolvedRemixRoutesId) {
         return generateRemixRoutes(await loadApp())
       }
@@ -988,6 +1041,12 @@ export function flamefront(options: FlamefrontOptions = {}) {
       }
 
       if (id === resolvedServerEntryId) {
+        if (devServer && (await loadApp()).document) {
+          // Development renders static routes too; production artifacts may be
+          // stale and must not bypass Vite's current document or asset graph.
+          return `import { createFetchServerEntry } from 'flamefront/fetch';\nexport function createServerEntry(options) {\n  const entry = createFetchServerEntry({ ...options, ${output.adapter === "srvx" ? "middleware: undefined," : ""} assets: { loadTemplate: options.assets.loadTemplate ?? (({ request }) => globalThis[Symbol.for(${quote(devTemplateLoadersKey)})].get(${quote(root)})(new URL(request.url).pathname)) } });\n  return ${output.adapter === "srvx" ? "{ ...entry, middleware: options.middleware }" : "entry"};\n}`
+        }
+
         return generateServerEntry(output)
       }