@getcronit/pylon 3.0.0-canary-20250303143548.bb9615641321063a172cd6af0a5cd52e2a2bc0a1 → 3.0.0-canary-20250312165655.826d17474bf64dfdbd9e31dd76e4f3898d48a6d1

package/dist/index.js

@@ -650,7 +650,7 @@ app.use("*", async (c, next) => {
     });
   });
 });
-app.use("*", except(["/__pylon/static/*"], logger()));
+app.use("*", except(["/__pylon/*"], logger()));
 app.use((c, next) => {
   c.req.id = crypto.randomUUID();
   return next();
@@ -1157,7 +1157,7 @@ var handler = (options) => {
     graphqlEndpoint: "/graphql",
     ...config,
     landingPage: false,
-    graphiql: !!config?.graphiql ? (req) => {
+    graphiql: config?.graphiql !== false ? (req) => {
       return {
         shouldPersistHeaders: true,
         title: "Pylon Playground",
@@ -1207,784 +1207,7 @@ function getEnv() {
 
 // src/index.ts
 import { createPubSub } from "graphql-yoga";
-
-// src/plugins/use-pages/setup/index.tsx
-import fs2 from "fs";
-import path3 from "path";
-import reactServer from "react-dom/server";
-import { PassThrough, Readable } from "stream";
-
-// src/plugins/use-pages/setup/app-loader.tsx
-import { useMemo } from "react";
-import { jsx } from "react/jsx-runtime";
-var AppLoader = (props) => {
-  props.client.useHydrateCache({ cacheSnapshot: props.pylonData.cacheSnapshot });
-  const data = props.client.useQuery();
-  const page = useMemo(() => {
-    const page2 = /* @__PURE__ */ jsx(
-      props.App,
-      {
-        pageProps: {
-          ...props.pylonData.pageProps,
-          data
-        }
-      }
-    );
-    return page2;
-  }, [props]);
-  return /* @__PURE__ */ jsx(props.Router, { ...props.routerProps, children: page });
-};
-
-// src/plugins/use-pages/setup/index.tsx
-import { trimTrailingSlash } from "hono/trailing-slash";
-import { StaticRouter } from "react-router";
-import { createHash } from "crypto";
-import { tmpdir } from "os";
-import { pipeline } from "stream/promises";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var disableCacheMiddleware = async (c, next) => {
-  const env3 = getEnv();
-  if (env3.NODE_ENV === "development") {
-    c.header(
-      "Cache-Control",
-      "no-store, no-cache, must-revalidate, proxy-revalidate"
-    );
-    c.header("Pragma", "no-cache");
-    c.header("Expires", "0");
-    c.header("Surrogate-Control", "no-store");
-  }
-  return next();
-};
-var setup = (app2) => {
-  const pagesFilePath = path3.resolve(process.cwd(), ".pylon", "pages.json");
-  let pageRoutes = [];
-  try {
-    pageRoutes = JSON.parse(fs2.readFileSync(pagesFilePath, "utf-8"));
-  } catch (error) {
-    console.error("Error reading pages.json", error);
-  }
-  app2.use(trimTrailingSlash());
-  let App = void 0;
-  let client = void 0;
-  app2.on(
-    "GET",
-    pageRoutes.map((pageRoute) => pageRoute.slug),
-    disableCacheMiddleware,
-    async (c) => {
-      if (!App) {
-        const module = await import(`${process.cwd()}/.pylon/__pylon/pages/app.js`);
-        App = module.default;
-      }
-      if (!client) {
-        client = await import(`${process.cwd()}/.pylon/client/index.js`);
-      }
-      const pageProps = {
-        params: c.req.param(),
-        searchParams: c.req.query(),
-        path: c.req.path
-      };
-      let cacheSnapshot = void 0;
-      const prepared = await client.prepareReactRender(
-        /* @__PURE__ */ jsx2(
-          AppLoader,
-          {
-            Router: StaticRouter,
-            routerProps: {
-              location: c.req.path
-            },
-            App,
-            client,
-            pylonData: {
-              pageProps,
-              cacheSnapshot: void 0
-            }
-          }
-        )
-      );
-      cacheSnapshot = prepared.cacheSnapshot;
-      if (reactServer.renderToReadableStream) {
-        const stream = await reactServer.renderToReadableStream(
-          /* @__PURE__ */ jsx2(
-            AppLoader,
-            {
-              Router: StaticRouter,
-              routerProps: {
-                location: c.req.path
-              },
-              App,
-              client,
-              pylonData: {
-                pageProps,
-                cacheSnapshot: prepared.cacheSnapshot
-              }
-            }
-          ),
-          {
-            bootstrapModules: ["/__pylon/static/app.js"],
-            bootstrapScriptContent: `window.__PYLON_DATA__ = ${JSON.stringify({
-              pageProps,
-              cacheSnapshot
-            })}`
-          }
-        );
-        return c.body(stream);
-      } else if (reactServer.renderToPipeableStream) {
-        let pipeableToReadable2 = function(pipeable) {
-          const passThrough = new PassThrough();
-          pipeable.pipe(passThrough);
-          return Readable.toWeb(passThrough);
-        };
-        var pipeableToReadable = pipeableToReadable2;
-        const pipableStream = reactServer.renderToPipeableStream(
-          /* @__PURE__ */ jsx2(
-            AppLoader,
-            {
-              Router: StaticRouter,
-              routerProps: {
-                location: c.req.path
-              },
-              App,
-              client,
-              pylonData: {
-                pageProps,
-                cacheSnapshot: prepared.cacheSnapshot
-              }
-            }
-          ),
-          {
-            bootstrapModules: ["/__pylon/static/app.js"],
-            bootstrapScriptContent: `window.__PYLON_DATA__ = ${JSON.stringify({
-              pageProps,
-              cacheSnapshot
-            })}`,
-            onShellReady: () => {
-              c.header("Content-Type", "text/html");
-            }
-          }
-        );
-        const stream = pipeableToReadable2(pipableStream);
-        return c.body(stream);
-      }
-    }
-  );
-  const publicFilesPath = path3.resolve(
-    process.cwd(),
-    ".pylon",
-    "__pylon",
-    "public"
-  );
-  let publicFiles = [];
-  try {
-    publicFiles = fs2.readdirSync(publicFilesPath);
-  } catch (error) {
-  }
-  app2.on(
-    "GET",
-    publicFiles.map((file) => `/${file}`),
-    disableCacheMiddleware,
-    async (c) => {
-      const publicFilePath = path3.resolve(
-        process.cwd(),
-        ".pylon",
-        "__pylon",
-        "public",
-        c.req.path.replace("/", "")
-      );
-      try {
-        await fs2.promises.access(publicFilePath);
-        if (publicFilePath.endsWith(".js")) {
-          c.res.headers.set("Content-Type", "text/javascript");
-        } else if (publicFilePath.endsWith(".css")) {
-          c.res.headers.set("Content-Type", "text/css");
-        } else if (publicFilePath.endsWith(".html")) {
-          c.res.headers.set("Content-Type", "text/html");
-        } else if (publicFilePath.endsWith(".json")) {
-          c.res.headers.set("Content-Type", "application/json");
-        } else if (publicFilePath.endsWith(".png")) {
-          c.res.headers.set("Content-Type", "image/png");
-        } else if (publicFilePath.endsWith(".jpg") || publicFilePath.endsWith(".jpeg")) {
-          c.res.headers.set("Content-Type", "image/jpeg");
-        } else if (publicFilePath.endsWith(".gif")) {
-          c.res.headers.set("Content-Type", "image/gif");
-        } else if (publicFilePath.endsWith(".svg")) {
-          c.res.headers.set("Content-Type", "image/svg+xml");
-        } else if (publicFilePath.endsWith(".ico")) {
-          c.res.headers.set("Content-Type", "image/x-icon");
-        }
-        const stream = fs2.createReadStream(publicFilePath);
-        const a = Readable.toWeb(stream);
-        return c.body(a);
-      } catch {
-        return c.status(404);
-      }
-    }
-  );
-  app2.get("/__pylon/static/*", disableCacheMiddleware, async (c) => {
-    const filePath = path3.resolve(
-      process.cwd(),
-      ".pylon",
-      "__pylon",
-      "static",
-      c.req.path.replace("/__pylon/static/", "")
-    );
-    if (!fs2.existsSync(filePath)) {
-      return c.status(404);
-    }
-    if (filePath.endsWith(".js")) {
-      c.res.headers.set("Content-Type", "text/javascript");
-    } else if (filePath.endsWith(".css")) {
-      c.res.headers.set("Content-Type", "text/css");
-    } else if (filePath.endsWith(".html")) {
-      c.res.headers.set("Content-Type", "text/html");
-    } else if (filePath.endsWith(".json")) {
-      c.res.headers.set("Content-Type", "application/json");
-    } else if (filePath.endsWith(".png")) {
-      c.res.headers.set("Content-Type", "image/png");
-    } else if (filePath.endsWith(".jpg") || filePath.endsWith(".jpeg")) {
-      c.res.headers.set("Content-Type", "image/jpeg");
-    } else if (filePath.endsWith(".gif")) {
-      c.res.headers.set("Content-Type", "image/gif");
-    } else if (filePath.endsWith(".svg")) {
-      c.res.headers.set("Content-Type", "image/svg+xml");
-    } else if (filePath.endsWith(".ico")) {
-      c.res.headers.set("Content-Type", "image/x-icon");
-    }
-    const stream = fs2.createReadStream(filePath);
-    const a = Readable.toWeb(stream);
-    return c.body(a);
-  });
-  app2.get("/__pylon/image", async (c) => {
-    try {
-      let isSupportedFormat2 = function(format2) {
-        const supportedFormats = sharp.format;
-        return Object.keys(supportedFormats).includes(format2);
-      };
-      var isSupportedFormat = isSupportedFormat2;
-      const sharp = (await import("sharp")).default;
-      const { src, w, h, q = "75", format = "webp" } = c.req.query();
-      const queryStringHash = createHash("sha256").update(JSON.stringify(c.req.query())).digest("hex");
-      if (!src) {
-        return c.json({ error: "Missing parameters." }, 400);
-      }
-      let imagePath = path3.join(process.cwd(), ".pylon", src);
-      if (src.startsWith("http://") || src.startsWith("https://")) {
-        imagePath = await downloadImage(src);
-      }
-      try {
-        await fs2.promises.access(imagePath);
-      } catch {
-        return c.json({ error: "Image not found" }, 404);
-      }
-      const metadata = await sharp(imagePath).metadata();
-      if (!metadata.width || !metadata.height) {
-        return c.json(
-          {
-            error: "Invalid image metadata. Width and height are required for resizing."
-          },
-          400
-        );
-      }
-      const { width: finalWidth, height: finalHeight } = calculateDimensions(
-        metadata.width,
-        metadata.height,
-        w ? parseInt(w) : void 0,
-        h ? parseInt(h) : void 0
-      );
-      const cachePath = path3.join(IMAGE_CACHE_DIR, queryStringHash);
-      let imageFormat = format.toLowerCase();
-      if (!isSupportedFormat2(imageFormat)) {
-        throw new Error("Unsupported image format");
-      }
-      const quality = parseInt(q);
-      if (IS_IMAGE_CACHE_POSSIBLE) {
-        const image = await sharp(imagePath).resize(finalWidth, finalHeight).toFormat(imageFormat, {
-          quality
-        }).toFile(cachePath);
-        c.res.headers.set("Content-Type", getContentType(image.format));
-        return c.body(
-          Readable.toWeb(
-            fs2.createReadStream(cachePath)
-          )
-        );
-      } else {
-        const image = await sharp(imagePath).resize(finalWidth, finalHeight).toFormat(imageFormat, {
-          quality
-        }).toBuffer({ resolveWithObject: true });
-        c.res.headers.set("Content-Type", getContentType(image.info.format));
-        return c.body(image.data);
-      }
-    } catch (error) {
-      console.error("Error processing the image:", error);
-      return c.json({ error: "Error processing the image" }, 500);
-    }
-  });
-};
-var IMAGE_CACHE_DIR = path3.join(process.cwd(), ".cache/__pylon/images");
-var IS_IMAGE_CACHE_POSSIBLE = true;
-try {
-  await fs2.promises.mkdir(IMAGE_CACHE_DIR, { recursive: true });
-} catch (error) {
-  IS_IMAGE_CACHE_POSSIBLE = false;
-}
-var calculateDimensions = (originalWidth, originalHeight, width, height) => {
-  if (!width && !height) {
-    return { width: originalWidth, height: originalHeight };
-  }
-  if (width && !height) {
-    height = Math.round(width * originalHeight / originalWidth);
-  } else if (height && !width) {
-    width = Math.round(height * originalWidth / originalHeight);
-  }
-  return { width, height };
-};
-var getContentType = (format) => {
-  switch (format.toLowerCase()) {
-    case "webp":
-      return "image/webp";
-    case "jpeg":
-    case "jpg":
-      return "image/jpeg";
-    case "png":
-      return "image/png";
-    case "gif":
-      return "image/gif";
-    case "svg":
-      return "image/svg+xml";
-    default:
-      return "application/octet-stream";
-  }
-};
-var downloadImage = async (url) => {
-  const response = await fetch(url);
-  if (!response.ok)
-    throw new Error(`Failed to download image: ${response.statusText}`);
-  const ext = path3.extname(new URL(url).pathname) || ".jpg";
-  const tempFilePath = path3.join(tmpdir(), `image-${Date.now()}${ext}`);
-  const fileStream = fs2.createWriteStream(tempFilePath);
-  await pipeline(response.body, fileStream);
-  return tempFilePath;
-};
-
-// src/plugins/use-pages/build/index.ts
-import path7 from "path";
-
-// src/plugins/use-pages/build/app-utils.ts
-import path4 from "path";
-import glob from "tiny-glob";
-function fnv1aHash(str) {
-  let hash = 2166136261;
-  for (let i = 0; i < str.length; i++) {
-    hash ^= str.charCodeAt(i);
-    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
-  }
-  return (hash >>> 0).toString(16);
-}
-var APP_DIR = path4.join(process.cwd(), "pages");
-async function getPageRoutes(dir = APP_DIR) {
-  const routes = [];
-  const pagePattern = path4.join(dir, "**/page.{ts,tsx,js}");
-  const layoutPattern = path4.join(dir, "**/layout.tsx");
-  const pageFiles = await glob(pagePattern);
-  const layoutFiles = await glob(layoutPattern);
-  for (const pagePath of pageFiles) {
-    const relativePagePath = path4.relative(APP_DIR, pagePath);
-    let slug = "/" + relativePagePath.replace(/page\.(ts|tsx|js)$/, "").replace(/\[([\w-]+)\]/g, ":$1");
-    slug = slug.replace(/\/$/, "");
-    const layouts = layoutFiles.filter((layout) => {
-      return pagePath.startsWith(layout.replace("layout.tsx", ""));
-    });
-    const layoutsWithoutRootLayout = layouts.slice(1);
-    routes.push({
-      pagePath,
-      slug: slug || "/",
-      layouts: layoutsWithoutRootLayout
-    });
-  }
-  return routes;
-}
-var generateAppFile = (pageRoutes) => {
-  const makePageMap = (routes) => {
-    const pageMap2 = {};
-    for (const route of routes) {
-      pageMap2[route.pagePath] = `Page${fnv1aHash(route.pagePath)}`;
-    }
-    return pageMap2;
-  };
-  const makeLayoutMap = (routes) => {
-    const layoutMap2 = {};
-    for (const route of routes) {
-      for (const layout of route.layouts) {
-        layoutMap2[layout] = `Layout${fnv1aHash(layout)}`;
-      }
-    }
-    return layoutMap2;
-  };
-  const pageMap = makePageMap(pageRoutes);
-  const layoutMap = makeLayoutMap(pageRoutes);
-  const importPages = Object.keys(pageMap).map((pagePath, index) => {
-    const importLocation = `../${pagePath}`.replace(".tsx", ".js");
-    const componentName = pageMap[pagePath];
-    return `const ${componentName} = lazy(() => import('${importLocation}'))
-      `;
-  }).join("\n");
-  const importLayouts = Object.keys(layoutMap).map((layoutPath, index) => {
-    const importLocation = `../${layoutPath}`.replace(".tsx", ".js");
-    const componentName = layoutMap[layoutPath];
-    return `const ${componentName} = lazy(() => import('${importLocation}'))
-      `;
-  }).join("\n");
-  const appComponent = `"use client";
-  import {lazy, Suspense} from 'react'
-  import { __PYLON_ROUTER_INTERNALS_DO_NOT_USE } from '@getcronit/pylon/pages';
-  const {Routes, Route} = __PYLON_ROUTER_INTERNALS_DO_NOT_USE
-  ${importPages}
-  const RootLayout = lazy(() => import('../pages/layout.js'))
-  ${importLayouts}
-  
-  const App: React.FC<{pageProps: any}> = ({pageProps}) => (
-  <RootLayout>
-      <meta charSet="utf-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1" />
-      <link rel="stylesheet" href="/__pylon/static/app.css" precedence="high" />
-         <Routes>
-        ${pageRoutes.map((route, index) => {
-    return `<Route key={${index}} index={${index === 0 ? "true" : "false"}} path="${route.slug}" element={
-         <Suspense fallback={<div>...</div>}>
-            ${route.layouts.reduceRight((child, layoutPath, layoutIndex) => {
-      const layoutName = layoutMap[layoutPath];
-      return `<${layoutName}>${child}</${layoutName}>`;
-    }, `<${pageMap[route.pagePath]} {...pageProps} />`)}
-
-         </Suspense>} />`;
-  }).join("\n")}
-    </Routes>
-    </RootLayout>
-  );
-  
-  export default App;
-    `;
-  return appComponent;
-};
-
-// src/plugins/use-pages/build/index.ts
-import chokidar from "chokidar";
-import fs6 from "fs/promises";
-import esbuild from "esbuild";
-
-// src/plugins/use-pages/build/plugins/inject-app-hydration.ts
-import path5 from "path";
-import fs3 from "fs/promises";
-var injectAppHydrationPlugin = {
-  name: "inject-hydration",
-  setup(build2) {
-    build2.onLoad({ filter: /.*/, namespace: "file" }, async (args) => {
-      if (args.path === path5.resolve(process.cwd(), ".pylon", "app.tsx")) {
-        let contents = await fs3.readFile(args.path, "utf-8");
-        const clientPath = path5.resolve(process.cwd(), ".pylon/client");
-        const pathToClient = path5.relative(path5.dirname(args.path), clientPath);
-        contents += `
-          import {hydrateRoot} from 'react-dom/client'
-          import * as client from './${pathToClient}'
-          import { __PYLON_ROUTER_INTERNALS_DO_NOT_USE } from '@getcronit/pylon/pages';
-          const {BrowserRouter} = __PYLON_ROUTER_INTERNALS_DO_NOT_USE
-          import React, {useMemo} from 'react'
-
-          const pylonData = window.__PYLON_DATA__
-
-          const AppLoader = (props: {
-            client: any
-            pylonData: {
-              pageProps: Omit<PageProps, 'data'>
-              cacheSnapshot?: any
-            }
-            App: React.FC<{
-              pageProps: PageProps
-            }>
-            Router: React.FC<any>
-            routerProps: any
-          }) => {
-            props.client.useHydrateCache({cacheSnapshot: props.pylonData.cacheSnapshot})
-          
-            const data = props.client.useQuery()
-            const page = useMemo(() => {
-              const page = (
-                <props.App
-                  pageProps={{
-                    ...props.pylonData.pageProps,
-                    data
-                  }}
-                />
-              )
-          
-              return page
-            }, [props])
-          
-            return <props.Router {...props.routerProps}>{page}</props.Router>
-          }
-          
-
-          hydrateRoot(
-          document,
-            <AppLoader Router={BrowserRouter} client={client} pylonData={pylonData} App={App} />
-          )
-          `;
-        return {
-          loader: "tsx",
-          contents
-        };
-      }
-    });
-  }
-};
-
-// src/plugins/use-pages/build/plugins/image-plugin.ts
-import { createHash as createHash2 } from "crypto";
-import path6 from "path";
-import fs4 from "fs/promises";
-var imagePlugin = {
-  name: "image-plugin",
-  setup(build2) {
-    const outdir = build2.initialOptions.outdir;
-    const publicPath = build2.initialOptions.publicPath;
-    if (!outdir || !publicPath) {
-      throw new Error("outdir and publicPath must be set in esbuild options");
-    }
-    build2.onResolve({ filter: /\.(png|jpe?g)$/ }, async (args) => {
-      const filePath = path6.resolve(args.resolveDir, args.path);
-      const fileName = path6.basename(filePath);
-      const extname = path6.extname(filePath);
-      const hash = createHash2("md5").update(filePath + await fs4.readFile(filePath)).digest("hex").slice(0, 8);
-      const newFilename = `${fileName}-${hash}${extname}`;
-      const newFilePath = path6.join(outdir, "media", newFilename);
-      await fs4.mkdir(path6.dirname(newFilePath), { recursive: true });
-      await fs4.copyFile(filePath, newFilePath);
-      return {
-        path: newFilePath,
-        namespace: "image"
-      };
-    });
-    build2.onLoad({ filter: /\.png$|\.jpg$/ }, async (args) => {
-      const sharp = (await import("sharp")).default;
-      const image = sharp(args.path);
-      const metadata = await image.metadata();
-      const url = `${publicPath}/media/${path6.basename(args.path)}`;
-      const searchParams = new URLSearchParams({});
-      if (metadata.width) {
-        searchParams.set("w", metadata.width.toString());
-      }
-      if (metadata.height) {
-        searchParams.set("h", metadata.height.toString());
-      }
-      const output = image.resize({
-        width: Math.min(metadata.width ?? 16, 16),
-        height: Math.min(metadata.height ?? 16, 16),
-        fit: "inside"
-      }).toFormat("webp", {
-        quality: 20,
-        alphaQuality: 20,
-        smartSubsample: true
-      });
-      const { data, info } = await output.toBuffer({ resolveWithObject: true });
-      const dataURIBase64 = `data:image/${info.format};base64,${data.toString(
-        "base64"
-      )}`;
-      if (dataURIBase64) {
-        searchParams.set("blurDataURL", dataURIBase64);
-      }
-      return {
-        contents: `${url}?${searchParams.toString()}`,
-        loader: "text"
-      };
-    });
-  }
-};
-
-// src/plugins/use-pages/build/plugins/postcss-plugin.ts
-import fs5 from "fs/promises";
-import loadConfig from "postcss-load-config";
-import postcss from "postcss";
-var postcssPlugin = {
-  name: "postcss-plugin",
-  setup(build2) {
-    build2.onLoad({ filter: /.css$/, namespace: "file" }, async (args) => {
-      const { plugins, options } = await loadConfig();
-      const css = await fs5.readFile(args.path, "utf-8");
-      const result = await postcss(plugins).process(css, {
-        ...options,
-        from: args.path
-      }).then((result2) => result2);
-      return {
-        contents: result.css,
-        loader: "css"
-      };
-    });
-  }
-};
-
-// src/plugins/use-pages/build/index.ts
-var DIST_STATIC_DIR = path7.join(process.cwd(), ".pylon/__pylon/static");
-var DIST_PAGES_DIR = path7.join(process.cwd(), ".pylon/__pylon/pages");
-async function updateFileIfChanged(path8, newContent) {
-  try {
-    const currentContent = await fs6.readFile(path8, "utf8");
-    if (currentContent === newContent) {
-      return false;
-    }
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-  await fs6.writeFile(path8, newContent, "utf8");
-  return true;
-}
-var build = async () => {
-  const buildAppFile = async () => {
-    const pagesRoutes = await getPageRoutes();
-    const appContent = generateAppFile(pagesRoutes);
-    const pagesFile = path7.resolve(process.cwd(), ".pylon", "pages.json");
-    await updateFileIfChanged(pagesFile, JSON.stringify(pagesRoutes, null, 2));
-    const appFilePath = path7.resolve(process.cwd(), ".pylon", "app.tsx");
-    const state = await updateFileIfChanged(appFilePath, appContent);
-    if (state) {
-    }
-  };
-  const copyPublicDir = async () => {
-    const publicDir = path7.resolve(process.cwd(), "public");
-    const pylonPublicDir = path7.resolve(
-      process.cwd(),
-      ".pylon",
-      "__pylon",
-      "public"
-    );
-    try {
-      await fs6.access(publicDir);
-      await fs6.mkdir(pylonPublicDir, { recursive: true });
-      await fs6.cp(publicDir, pylonPublicDir, { recursive: true });
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  };
-  const writeOnEndPlugin = {
-    name: "write-on-end",
-    setup(build2) {
-      build2.onEnd(async (result) => {
-        await Promise.all(
-          result.outputFiles.map(async (file) => {
-            await fs6.mkdir(path7.dirname(file.path), { recursive: true });
-            await updateFileIfChanged(file.path, file.text);
-          })
-        );
-      });
-    }
-  };
-  const nodePaths = [
-    path7.join(process.cwd(), "node_modules"),
-    path7.join(process.cwd(), "node_modules", "@getcronit/pylon/node_modules")
-  ];
-  let pagesWatcher = null;
-  const clientCtx = await esbuild.context({
-    sourcemap: "linked",
-    write: false,
-    metafile: true,
-    nodePaths,
-    absWorkingDir: process.cwd(),
-    plugins: [
-      injectAppHydrationPlugin,
-      imagePlugin,
-      postcssPlugin,
-      writeOnEndPlugin
-    ],
-    publicPath: "/__pylon/static",
-    assetNames: "assets/[name]-[hash]",
-    chunkNames: "chunks/[name]-[hash]",
-    format: "esm",
-    platform: "browser",
-    entryPoints: [".pylon/app.tsx"],
-    outdir: DIST_STATIC_DIR,
-    bundle: true,
-    splitting: true,
-    minify: true,
-    loader: {
-      // Map file extensions to the file loader
-      ".svg": "file",
-      ".woff": "file",
-      ".woff2": "file"
-    },
-    define: {
-      "process.env.NODE_ENV": JSON.stringify(
-        process.env.NODE_ENV || "development"
-      )
-    },
-    mainFields: ["browser", "module", "main"]
-  });
-  const serverCtx = await esbuild.context({
-    sourcemap: "inline",
-    write: false,
-    absWorkingDir: process.cwd(),
-    nodePaths,
-    plugins: [imagePlugin, postcssPlugin, writeOnEndPlugin],
-    publicPath: "/__pylon/static",
-    assetNames: "assets/[name]-[hash]",
-    chunkNames: "chunks/[name]-[hash]",
-    format: "esm",
-    platform: "node",
-    entryPoints: [".pylon/app.tsx"],
-    outdir: DIST_PAGES_DIR,
-    bundle: true,
-    splitting: false,
-    external: ["@getcronit/pylon", "react", "react-dom", "gqty", "@gqty/react"],
-    minify: true,
-    loader: {
-      // Map file extensions to the file loader
-      ".svg": "file",
-      ".woff": "file",
-      ".woff2": "file"
-    },
-    define: {
-      "process.env.NODE_ENV": JSON.stringify(
-        process.env.NODE_ENV || "development"
-      )
-    },
-    mainFields: ["module", "main"]
-  });
-  return {
-    watch: async () => {
-      pagesWatcher = chokidar.watch("pages", { ignoreInitial: true });
-      pagesWatcher.on("all", async (event, path8) => {
-        if (["add", "change", "unlink"].includes(event)) {
-          await buildAppFile();
-          await copyPublicDir();
-        }
-      });
-      await Promise.all([clientCtx.watch(), serverCtx.watch()]);
-    },
-    dispose: async () => {
-      if (pagesWatcher) {
-        pagesWatcher.close();
-      }
-      Promise.all([clientCtx.dispose(), serverCtx.dispose()]);
-    },
-    rebuild: async () => {
-      await buildAppFile();
-      await copyPublicDir();
-      await Promise.all([clientCtx.rebuild(), serverCtx.rebuild()]);
-      return {};
-    },
-    cancel: async () => {
-      if (pagesWatcher) {
-        await pagesWatcher.close();
-      }
-      await Promise.all([clientCtx.cancel(), serverCtx.cancel()]);
-    }
-  };
-};
-
-// src/plugins/use-pages/index.ts
-function usePages() {
-  return {
-    setup,
-    build
-  };
-}
+import { usePages } from "@getcronit/pylon-pages";
 export {
   ServiceError,
   app,