houdini-react 1.2.12 → 1.2.14

package/build/plugin-cjs/index.js

@@ -16419,7 +16419,6 @@ var import_node_util4 = require("node:util");
 var graphql3 = __toESM(require("graphql"), 1);
 var graphql4 = __toESM(require("graphql"), 1);
 var graphql5 = __toESM(require("graphql"), 1);
-var import_vite = require("vite");
 var import_meta = {};
 var require2 = (0, import_module.createRequire)(import_meta.url);
 var __create2 = Object.create;
@@ -74894,8 +74893,8 @@ function computeID(configFile, type, data) {
   return id.slice(0, -2);
 }
 var _configFile = null;
-function localApiSessionKeys(configFile) {
-  return configFile.router?.auth?.sessionKeys ?? [];
+function localApiEndpoint(configFile) {
+  return configFile.router?.apiEndpoint ?? "/_api";
 }
 function getCurrentConfig() {
   const mockConfig2 = getMockConfig();
@@ -75587,10 +75586,10 @@ var validateHeaderValue = typeof import_node_http.default.validateHeaderValue ==
     throw error;
   }
 };
-var Headers2 = class extends URLSearchParams {
+var Headers = class extends URLSearchParams {
   constructor(init) {
     let result = [];
-    if (init instanceof Headers2) {
+    if (init instanceof Headers) {
       const raw = init.raw();
       for (const [name, values] of Object.entries(raw)) {
         result.push(...values.map((value) => [name, value]));
@@ -75714,7 +75713,7 @@ var Headers2 = class extends URLSearchParams {
   }
 };
 Object.defineProperties(
-  Headers2.prototype,
+  Headers.prototype,
   ["get", "entries", "forEach", "values"].reduce((result, property) => {
     result[property] = { enumerable: true };
     return result;
@@ -75729,7 +75728,7 @@ var Response2 = class extends Body {
   constructor(body = null, options = {}) {
     super(body, options);
     const status = options.status != null ? options.status : 200;
-    const headers = new Headers2(options.headers);
+    const headers = new Headers(options.headers);
     if (body !== null && !headers.has("Content-Type")) {
       const contentType = extractContentType(body, this);
       if (contentType) {
@@ -75804,7 +75803,7 @@ var Response2 = class extends Body {
     if (body === void 0) {
       throw new TypeError("data is not JSON serializable");
     }
-    const headers = new Headers2(init && init.headers);
+    const headers = new Headers(init && init.headers);
     if (!headers.has("content-type")) {
       headers.set("content-type", "application/json");
     }
@@ -75880,7 +75879,7 @@ var Request2 = class extends Body {
     super(inputBody, {
       size: init.size || input.size || 0
     });
-    const headers = new Headers2(init.headers || input.headers || {});
+    const headers = new Headers(init.headers || input.headers || {});
     if (inputBody !== null && !headers.has("Content-Type")) {
       const contentType = extractContentType(inputBody, this);
       if (contentType) {
@@ -78239,7 +78238,7 @@ var mutation = documentPlugin(ArtifactKind.Mutation, () => {
     }
   };
 });
-var currentDir = global.__dirname || dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+var currentDir = dirname((0, import_node_url.fileURLToPath)(import_meta.url));
 var DEFAULT_CONFIG_PATH = join2(process.cwd(), "houdini.config.js");
 var emptySchema = graphql2.buildSchema("type Query { hello: String }");
 var defaultDirectives = emptySchema.getDirectives().map((dir) => dir.name);
@@ -78321,6 +78320,122 @@ function ensureImports({
   }
   return Array.isArray(importID) ? toImport : toImport[0];
 }
+var param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
+function find_match(manifest3, current, allowNull = true) {
+  let match = null;
+  let matchVariables = null;
+  for (const page of Object.values(manifest3.pages)) {
+    const urlMatch = current.match(page.pattern);
+    if (!urlMatch) {
+      continue;
+    }
+    match = page;
+    matchVariables = exec(urlMatch, page.params) || {};
+    break;
+  }
+  if (!match && !allowNull) {
+    throw new Error("404");
+  }
+  return [match, matchVariables];
+}
+function parse_page_pattern(id) {
+  const params = [];
+  const pattern = id === "/" ? /^\/$/ : new RegExp(
+    `^${get_route_segments(id).map((segment) => {
+      const rest_match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
+      if (rest_match) {
+        params.push({
+          name: rest_match[1],
+          matcher: rest_match[2],
+          optional: false,
+          rest: true,
+          chained: true
+        });
+        return "(?:/(.*))?";
+      }
+      const optional_match = /^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(segment);
+      if (optional_match) {
+        params.push({
+          name: optional_match[1],
+          matcher: optional_match[2],
+          optional: true,
+          rest: false,
+          chained: true
+        });
+        return "(?:/([^/]+))?";
+      }
+      if (!segment) {
+        return;
+      }
+      const parts = segment.split(/\[(.+?)\](?!\])/);
+      const result = parts.map((content, i2) => {
+        if (i2 % 2) {
+          if (content.startsWith("x+")) {
+            return escape2(
+              String.fromCharCode(parseInt(content.slice(2), 16))
+            );
+          }
+          if (content.startsWith("u+")) {
+            return escape2(
+              String.fromCharCode(
+                ...content.slice(2).split("-").map((code) => parseInt(code, 16))
+              )
+            );
+          }
+          const match = param_pattern.exec(content);
+          if (!match) {
+            throw new Error(
+              `Invalid param: ${content}. Params and matcher names can only have underscores and alphanumeric characters.`
+            );
+          }
+          const [, is_optional, is_rest, name, matcher] = match;
+          params.push({
+            name,
+            matcher,
+            optional: !!is_optional,
+            rest: !!is_rest,
+            chained: is_rest ? i2 === 1 && parts[0] === "" : false
+          });
+          return is_rest ? "(.*?)" : is_optional ? "([^/]*)?" : "([^/]+?)";
+        }
+        return escape2(content);
+      }).join("");
+      return "/" + result;
+    }).join("")}/?$`
+  );
+  return { pattern, params, page_id: id };
+}
+function affects_path(segment) {
+  return !/^\([^)]+\)$/.test(segment);
+}
+function get_route_segments(route) {
+  return route.slice(1).split("/").filter(affects_path);
+}
+function exec(match, params) {
+  const result = {};
+  const values = match.slice(1);
+  let buffered = "";
+  for (let i2 = 0; i2 < params.length; i2 += 1) {
+    const param = params[i2];
+    let value = values[i2];
+    if (param.chained && param.rest && buffered) {
+      value = value ? buffered + "/" + value : buffered;
+    }
+    buffered = "";
+    if (value === void 0) {
+      if (param.rest)
+        result[param.name] = "";
+    } else {
+      result[param.name] = value;
+    }
+  }
+  if (buffered)
+    return;
+  return result;
+}
+function escape2(str) {
+  return str.normalize().replace(/[[\]]/g, "\\$&").replace(/%/g, "%25").replace(/\//g, "%2[Ff]").replace(/\?/g, "%3[Ff]").replace(/#/g, "%23").replace(/[.*+?^${}()|\\]/g, "\\$&");
+}
 var WalkerBase = class {
   constructor() {
     this.should_skip = false;
@@ -78498,6 +78613,7 @@ async function find_graphql(config2, parsedScript, walker) {
 }
 var conventions_exports = {};
 __export2(conventions_exports, {
+  adapter_config_path: () => adapter_config_path,
   fallback_unit_path: () => fallback_unit_path,
   is_layout: () => is_layout,
   layout_unit_path: () => layout_unit_path,
@@ -78509,13 +78625,10 @@ __export2(conventions_exports, {
   read_layoutView: () => read_layoutView,
   read_pageQuery: () => read_pageQuery,
   read_pageView: () => read_pageView,
-  render_app_path: () => render_app_path,
-  render_client_path: () => render_client_path,
-  render_server_path: () => render_server_path,
-  render_yoga_path: () => render_yoga_path,
   router_index_path: () => router_index_path,
   router_path: () => router_path,
-  serialized_manifest_path: () => serialized_manifest_path
+  serialized_manifest_path: () => serialized_manifest_path,
+  server_adapter_path: () => server_adapter_path
 });
 function router_path(config2) {
   return path_exports.join(base_dir(config2), "Router.jsx");
@@ -78523,17 +78636,11 @@ function router_path(config2) {
 function page_entry_path(config2, id, base) {
   return path_exports.join(page_entries_dir(config2, base), `${id}.jsx`);
 }
-function render_client_path(config2, base) {
-  return path_exports.join(units_dir(config2, base), "render", "client.jsx");
-}
-function render_server_path(config2, base) {
+function server_adapter_path(config2, base) {
   return path_exports.join(units_dir(config2, base), "render", "server.js");
 }
-function render_yoga_path(config2, base) {
-  return path_exports.join(units_dir(config2, base), "render", "yoga.js");
-}
-function render_app_path(config2, base) {
-  return path_exports.join(units_dir(config2, base), "render", "App.jsx");
+function adapter_config_path(config2, base) {
+  return path_exports.join(units_dir(config2, base), "render", "config.js");
 }
 function page_unit_path(config2, id, base) {
   return path_exports.join(page_units_dir(config2, base), `${id}.jsx`);
@@ -78839,252 +78946,13 @@ async function extractQueries(source) {
   }
   return props.filter((p) => p !== "children");
 }
-function isViteSchemaBuild() {
+function isSecondaryBuild() {
   return process.env.HOUDINI_SCHEMA_BUILD === "true";
 }
-function parse6(str, options) {
-  if (typeof str !== "string") {
-    throw new TypeError("argument str must be a string");
-  }
-  let obj = {};
-  let opt = options || {};
-  let dec = opt.decode || decode;
-  let index = 0;
-  while (index < str.length) {
-    let eqIdx = str.indexOf("=", index);
-    if (eqIdx === -1) {
-      break;
-    }
-    let endIdx = str.indexOf(";", index);
-    if (endIdx === -1) {
-      endIdx = str.length;
-    } else if (endIdx < eqIdx) {
-      index = str.lastIndexOf(";", eqIdx - 1) + 1;
-      continue;
-    }
-    let key = str.slice(index, eqIdx).trim();
-    if (void 0 === obj[key]) {
-      let val = str.slice(eqIdx + 1, endIdx).trim();
-      if (val.charCodeAt(0) === 34) {
-        val = val.slice(1, -1);
-      }
-      obj[key] = tryDecode(val, dec);
-    }
-    index = endIdx + 1;
-  }
-  return obj;
-}
-function decode(str) {
-  return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
-}
-function tryDecode(str, decode3) {
-  try {
-    return decode3(str);
-  } catch (e2) {
-    return str;
-  }
-}
-function base64UrlParse(s2) {
-  return new Uint8Array(
-    Array.prototype.map.call(
-      atob(s2.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "")),
-      (c) => c.charCodeAt(0)
-    )
-  );
-}
-function base64UrlStringify(a) {
-  return btoa(String.fromCharCode.apply(0, a)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-}
-var algorithms = {
-  ES256: { name: "ECDSA", namedCurve: "P-256", hash: { name: "SHA-256" } },
-  ES384: { name: "ECDSA", namedCurve: "P-384", hash: { name: "SHA-384" } },
-  ES512: { name: "ECDSA", namedCurve: "P-521", hash: { name: "SHA-512" } },
-  HS256: { name: "HMAC", hash: { name: "SHA-256" } },
-  HS384: { name: "HMAC", hash: { name: "SHA-384" } },
-  HS512: { name: "HMAC", hash: { name: "SHA-512" } },
-  RS256: { name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-256" } },
-  RS384: { name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-384" } },
-  RS512: { name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-512" } }
-};
-function _utf8ToUint8Array(str) {
-  return base64UrlParse(btoa(unescape(encodeURIComponent(str))));
-}
-function _str2ab(str) {
-  str = atob(str);
-  const buf = new ArrayBuffer(str.length);
-  const bufView = new Uint8Array(buf);
-  for (let i2 = 0, strLen = str.length; i2 < strLen; i2++) {
-    bufView[i2] = str.charCodeAt(i2);
-  }
-  return buf;
-}
-function _decodePayload(raw) {
-  switch (raw.length % 4) {
-    case 0:
-      break;
-    case 2:
-      raw += "==";
-      break;
-    case 3:
-      raw += "=";
-      break;
-    default:
-      throw new Error("Illegal base64url string!");
-  }
-  try {
-    return JSON.parse(decodeURIComponent(escape(atob(raw))));
-  } catch {
-    return null;
-  }
-}
-async function encode(payload, secret, options = { algorithm: "HS256", header: { typ: "JWT" } }) {
-  if (typeof options === "string")
-    options = { algorithm: options, header: { typ: "JWT" } };
-  options = { algorithm: "HS256", header: { typ: "JWT" }, ...options };
-  if (payload === null || typeof payload !== "object")
-    throw new Error("payload must be an object");
-  if (typeof secret !== "string" && typeof secret !== "object")
-    throw new Error("secret must be a string or a JWK object");
-  if (typeof options.algorithm !== "string")
-    throw new Error("options.algorithm must be a string");
-  const algorithm = algorithms[options.algorithm];
-  if (!algorithm)
-    throw new Error("algorithm not found");
-  if (!payload.iat)
-    payload.iat = Math.floor(Date.now() / 1e3);
-  const payloadAsJSON = JSON.stringify(payload);
-  const partialToken = `${base64UrlStringify(
-    _utf8ToUint8Array(JSON.stringify({ ...options.header, alg: options.algorithm }))
-  )}.${base64UrlStringify(_utf8ToUint8Array(payloadAsJSON))}`;
-  let keyFormat = "raw";
-  let keyData;
-  if (typeof secret === "object") {
-    keyFormat = "jwk";
-    keyData = secret;
-  } else if (typeof secret === "string" && secret.startsWith("-----BEGIN")) {
-    keyFormat = "pkcs8";
-    keyData = _str2ab(
-      secret.replace(/-----BEGIN.*?-----/g, "").replace(/-----END.*?-----/g, "").replace(/\s/g, "")
-    );
-  } else
-    keyData = _utf8ToUint8Array(secret);
-  const key = await crypto.subtle.importKey(keyFormat, keyData, algorithm, false, ["sign"]);
-  const signature = await crypto.subtle.sign(algorithm, key, _utf8ToUint8Array(partialToken));
-  return `${partialToken}.${base64UrlStringify(new Uint8Array(signature))}`;
-}
-async function verify(token, secret, options = { algorithm: "HS256", throwError: false }) {
-  if (typeof options === "string")
-    options = { algorithm: options, throwError: false };
-  options = { algorithm: "HS256", throwError: false, ...options };
-  if (typeof token !== "string")
-    throw new Error("token must be a string");
-  if (typeof secret !== "string" && typeof secret !== "object")
-    throw new Error("secret must be a string or a JWK object");
-  if (typeof options.algorithm !== "string")
-    throw new Error("options.algorithm must be a string");
-  const tokenParts = token.split(".");
-  if (tokenParts.length !== 3)
-    throw new Error("token must consist of 3 parts");
-  const algorithm = algorithms[options.algorithm];
-  if (!algorithm)
-    throw new Error("algorithm not found");
-  const { payload } = decode2(token);
-  if (!payload) {
-    if (options.throwError)
-      throw "PARSE_ERROR";
-    return false;
-  }
-  if (payload.nbf && payload.nbf > Math.floor(Date.now() / 1e3)) {
-    if (options.throwError)
-      throw "NOT_YET_VALID";
-    return false;
-  }
-  if (payload.exp && payload.exp <= Math.floor(Date.now() / 1e3)) {
-    if (options.throwError)
-      throw "EXPIRED";
-    return false;
-  }
-  let keyFormat = "raw";
-  let keyData;
-  if (typeof secret === "object") {
-    keyFormat = "jwk";
-    keyData = secret;
-  } else if (typeof secret === "string" && secret.startsWith("-----BEGIN")) {
-    keyFormat = "spki";
-    keyData = _str2ab(
-      secret.replace(/-----BEGIN.*?-----/g, "").replace(/-----END.*?-----/g, "").replace(/\s/g, "")
-    );
-  } else
-    keyData = _utf8ToUint8Array(secret);
-  const key = await crypto.subtle.importKey(keyFormat, keyData, algorithm, false, ["verify"]);
-  return await crypto.subtle.verify(
-    algorithm,
-    key,
-    base64UrlParse(tokenParts[2]),
-    _utf8ToUint8Array(`${tokenParts[0]}.${tokenParts[1]}`)
-  );
-}
-function decode2(token) {
-  return {
-    header: _decodePayload(
-      token.split(".")[0].replace(/-/g, "+").replace(/_/g, "/")
-    ),
-    payload: _decodePayload(
-      token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/")
-    )
-  };
-}
-async function handle_request(args) {
-  const plugin_config = args.config.router ?? {};
-  if (plugin_config.auth && "redirect" in plugin_config.auth && args.url.startsWith(plugin_config.auth.redirect)) {
-    return await redirect_auth(args);
-  }
-  args.next();
-}
-async function redirect_auth(args) {
-  const { searchParams } = new URL(args.url, `http://${args.get_header("host")}`);
-  const { redirectTo, ...session } = Object.fromEntries(searchParams.entries());
-  await set_session(args, session);
-  if (redirectTo) {
-    return args.redirect(302, redirectTo);
-  }
-  args.next();
-}
-var session_cookie_name = "__houdini__";
-async function set_session(req, value) {
-  const today = new Date();
-  const expires = new Date(today.getTime() + 7 * 24 * 60 * 60 * 1e3);
-  const serialized = await encode(value, req.session_keys[0]);
-  req.set_header(
-    "Set-Cookie",
-    `${session_cookie_name}=${serialized}; Path=/; HttpOnly; Secure; SameSite=Lax; Expires=${expires.toUTCString()} `
-  );
-}
-async function get_session(req, secrets) {
-  const cookies = req.get("cookie");
-  if (!cookies) {
-    return {};
-  }
-  const cookie = parse6(cookies)[session_cookie_name];
-  if (!cookie) {
-    return {};
-  }
-  for (const secret of secrets) {
-    if (!await verify(cookie, secret)) {
-      continue;
-    }
-    const parsed = decode2(cookie);
-    if (!parsed) {
-      return {};
-    }
-    return parsed.payload;
-  }
-  return {};
-}
 
 // src/plugin/index.ts
 var import_node_path2 = __toESM(require("node:path"));
-var import_vite2 = require("vite");
+var import_vite = require("vite");
 
 // src/plugin/codegen/entries.ts
 async function generate_entries({
@@ -79117,7 +78985,7 @@ async function generate_routing_units(args) {
   const relative_path = path_exports.relative(path_exports.dirname(unit_path), page_path);
   const component_name = "Component_" + page.id;
   let source = [
-    "import { useQueryResult } from '$houdini/plugins/houdini-react/runtime/routing/components/Router'",
+    "import { useQueryResult } from '$houdini/plugins/houdini-react/runtime/routing'",
     `import ${component_name} from "${relative_path}"`
   ];
   source.push(`export default ({ children }) => {
@@ -79309,52 +79177,96 @@ async function write_manifest({
 }
 
 // src/plugin/codegen/render.ts
-async function generate_renders(config) {
-  await fs_exports.mkdirp(path_exports.dirname(conventions_exports.render_client_path(config)));
-  const app_index = `
-import React from 'react'
-import Shell from '../../../../../src/+index'
-import { Router } from '$houdini'
+async function generate_renders({
+  config,
+  manifest: manifest3
+}) {
+  await fs_exports.mkdirp(path_exports.dirname(conventions_exports.server_adapter_path(config)));
+  let adapter_config = `
+		import createAdapter from './server'
 
-export default (props) => <Shell><Router {...props} /></Shell>
-`;
-  const render_server = `
+		export const endpoint = ${JSON.stringify(localApiEndpoint(config.configFile))}
+
+		${manifest3.local_schema ? `import schema from '../../../../../src/api/+schema'` : " const schema = null"}
+
+		${manifest3.local_yoga ? `import yoga from '.../../../../../src/api/+yoga'` : " const yoga = null"}
+
+		export function createServerAdapter(options) {
+			return createAdapter({
+				schema,
+				yoga,
+				graphqlEndpoint: endpoint,
+				...options,
+			})
+		}
+	`;
+  const server_adapter = `
 import React from 'react'
 import { renderToStream } from 'react-streaming/server'
+import { Cache } from '$houdini/runtime/cache/cache'
+import { serverAdapterFactory } from '$houdini/runtime/router/server'
 
-import App from './App'
-import { router_cache } from '$houdini'
+import { Router, router_cache } from '../../runtime'
+import manifest from '../../runtime/manifest'
 
-export function render_to_stream({url, cache, loaded_queries, loaded_artifacts, session, assetPrefix, ...config}) {
-	return renderToStream(
-		React.createElement(App, {
-			initialURL: url,
-			cache,
-			...router_cache(),
-			loaded_queries,
-			session,
-			loaded_artifacts,
-			assetPrefix,
-		}), config
-	)
-}
-`;
-  const create_yoga = `
-import { createYoga } from 'graphql-yoga'
-import internalSchema from '../../../../../src/api/+schema'
+import Shell from '../../../../../src/+index'
+
+export default (options) => {
+	return serverAdapterFactory({
+		manifest,
+		...options,
+		on_render: async ({url, match, session, pipe , manifest }) => {
+			// instanitate a cache we can use for this request
+			const cache = new Cache({ disabled: false })
+
+			if (!match) {
+				return new Response('not found', { status: 404 })
+			}
+
+			const { readable, injectToStream, pipe: pipeTo } = await renderToStream(
+				React.createElement(Shell, {
+					children: React.createElement(Router, {
+						initialURL: url,
+						cache: cache,
+						session: session,
+						assetPrefix: options.assetPrefix,
+						manifest: manifest,
+						...router_cache()
+					})
+				}),
+				{
+					userAgent: 'Vite',
+				}
+			)
+
+			// add the initial scripts to the page
+			injectToStream(\`
+				<script>
+					window.__houdini__initial__cache__ = \${cache.serialize()};
+					window.__houdini__initial__session__ = \${JSON.stringify(session)};
+				<\/script>
+
+				<!--
+					add a virtual module that hydrates the client and sets up the initial pending cache.
+					the dynamic extension is to support dev which sees the raw jsx, and production which sees the bundled asset
+				-->
+				<script type="module" src="\${options.assetPrefix}/pages/\${match.id}.\${options.production ? 'js' : 'jsx'}" async=""><\/script>
+			\`)
 
-export default function({ schema = internalSchema, ...opts } = {}) {
-	return createYoga({
-		schema,
-		landingPage: false,
-		...opts
+			if (pipe && pipeTo) {
+				// pipe the response to the client
+				pipeTo(pipe)
+			} else {
+				// and deliver our Response while that's running.
+				return new Response(readable)
+			}
+		},
 	})
 }
 	`;
   await Promise.all([
-    fs_exports.writeFile(conventions_exports.render_server_path(config), render_server),
-    fs_exports.writeFile(conventions_exports.render_app_path(config), app_index),
-    fs_exports.writeFile(conventions_exports.render_yoga_path(config), create_yoga)
+    fs_exports.writeFile(conventions_exports.server_adapter_path(config), server_adapter),
+    fs_exports.writeFile(conventions_exports.adapter_config_path(config), adapter_config)
   ]);
 }
 
@@ -79484,130 +79396,12 @@ async function routerCodegen({
 }) {
   await Promise.all([
     generate_entries({ config, manifest: manifest3 }),
-    generate_renders(config),
+    generate_renders({ config, manifest: manifest3 }),
     generate_type_root({ config, manifest: manifest3 }),
     write_manifest({ config, manifest: manifest3 })
   ]);
 }
 
-// src/runtime/routing/lib/match.ts
-var param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
-function find_match(manifest3, current, allowNull) {
-  let match = null;
-  let matchVariables = null;
-  for (const page of Object.values(manifest3.pages)) {
-    const urlMatch = current.match(page.pattern);
-    if (!urlMatch) {
-      continue;
-    }
-    match = page;
-    matchVariables = exec(urlMatch, page.params) || {};
-    break;
-  }
-  if (!match && !allowNull) {
-    throw new Error("404");
-  }
-  return [match, matchVariables];
-}
-function parse_page_pattern(id) {
-  const params = [];
-  const pattern = id === "/" ? /^\/$/ : new RegExp(
-    `^${get_route_segments(id).map((segment) => {
-      const rest_match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
-      if (rest_match) {
-        params.push({
-          name: rest_match[1],
-          matcher: rest_match[2],
-          optional: false,
-          rest: true,
-          chained: true
-        });
-        return "(?:/(.*))?";
-      }
-      const optional_match = /^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(segment);
-      if (optional_match) {
-        params.push({
-          name: optional_match[1],
-          matcher: optional_match[2],
-          optional: true,
-          rest: false,
-          chained: true
-        });
-        return "(?:/([^/]+))?";
-      }
-      if (!segment) {
-        return;
-      }
-      const parts = segment.split(/\[(.+?)\](?!\])/);
-      const result = parts.map((content, i2) => {
-        if (i2 % 2) {
-          if (content.startsWith("x+")) {
-            return escape2(
-              String.fromCharCode(parseInt(content.slice(2), 16))
-            );
-          }
-          if (content.startsWith("u+")) {
-            return escape2(
-              String.fromCharCode(
-                ...content.slice(2).split("-").map((code) => parseInt(code, 16))
-              )
-            );
-          }
-          const match = param_pattern.exec(content);
-          if (!match) {
-            throw new Error(
-              `Invalid param: ${content}. Params and matcher names can only have underscores and alphanumeric characters.`
-            );
-          }
-          const [, is_optional, is_rest, name, matcher] = match;
-          params.push({
-            name,
-            matcher,
-            optional: !!is_optional,
-            rest: !!is_rest,
-            chained: is_rest ? i2 === 1 && parts[0] === "" : false
-          });
-          return is_rest ? "(.*?)" : is_optional ? "([^/]*)?" : "([^/]+?)";
-        }
-        return escape2(content);
-      }).join("");
-      return "/" + result;
-    }).join("")}/?$`
-  );
-  return { pattern, params, page_id: id };
-}
-function affects_path(segment) {
-  return !/^\([^)]+\)$/.test(segment);
-}
-function get_route_segments(route) {
-  return route.slice(1).split("/").filter(affects_path);
-}
-function exec(match, params) {
-  const result = {};
-  const values = match.slice(1);
-  let buffered = "";
-  for (let i2 = 0; i2 < params.length; i2 += 1) {
-    const param = params[i2];
-    let value = values[i2];
-    if (param.chained && param.rest && buffered) {
-      value = value ? buffered + "/" + value : buffered;
-    }
-    buffered = "";
-    if (value === void 0) {
-      if (param.rest)
-        result[param.name] = "";
-    } else {
-      result[param.name] = value;
-    }
-  }
-  if (buffered)
-    return;
-  return result;
-}
-function escape2(str) {
-  return str.normalize().replace(/[[\]]/g, "\\$&").replace(/%/g, "%25").replace(/\//g, "%2[Ff]").replace(/\?/g, "%3[Ff]").replace(/#/g, "%23").replace(/[.*+?^${}()|\\]/g, "\\$&");
-}
-
 // src/plugin/codegen/router.ts
 function format_router_manifest({
   config,
@@ -79754,7 +79548,8 @@ var vite_default = {
         }
       }
     };
-    if (!isViteSchemaBuild()) {
+    if (!isSecondaryBuild()) {
+      await fs_exports.mkdirp(config.compiledAssetsDir);
       rollupConfig.outDir = config.compiledAssetsDir;
       rollupConfig.rollupOptions.input = {};
       for (const [id, page] of Object.entries(manifest.pages)) {
@@ -79791,7 +79586,7 @@ var vite_default = {
     arg = parsedPath.name;
     if (which === "pages") {
       const [id2, query_names] = arg.split("@");
-      const queries = query_names.split(",");
+      const queries = query_names ? query_names.split(",") : [];
       return `
 				import { hydrateRoot } from 'react-dom/client';
 				import App from '$houdini/plugins/houdini-react/units/render/App'
@@ -79800,6 +79595,7 @@ var vite_default = {
 				import client from '$houdini/plugins/houdini-react/runtime/client'
 				import Component from '$houdini/plugins/houdini-react/units/entries/${id2}.jsx'
 
+
 				// if there is pending data (or artifacts) then we should prime the caches
 				let initialData = {}
 				let initialArtifacts = {}
@@ -79807,7 +79603,7 @@ var vite_default = {
 				if (!window.__houdini__cache__) {
 					window.__houdini__cache__ = new Cache()
 					window.__houdini__hydration__layer__ = window.__houdini__cache__._internal_unstable.storage.createLayer(true)
-					window.__houdini__client__ = client
+					window.__houdini__client__ = client()
 				}
 
 				// the artifacts are the source of the zip (without them, we can't prime either cache)
@@ -79818,7 +79614,7 @@ var vite_default = {
 					// if we also have data for the artifact, save it in the initial data cache
 					if (window.__houdini__pending_data__?.[artifactName]) {
 						// create the store we'll put in the cache
-						const observer = client.observe({ artifact, cache: window.__houdini__cache__, initialValue: window.__houdini__pending_data__[artifactName] })
+						const observer = window.__houdini__client__.observe({ artifact, cache: window.__houdini__cache__, initialValue: window.__houdini__pending_data__[artifactName] })
 
 						// save it in the cache
 						initialData[artifactName] = observer
@@ -79861,113 +79657,56 @@ if (window.__houdini__nav_caches__ && window.__houdini__nav_caches__.artifact_ca
 `;
     }
   },
-  configureServer(server) {
-    if (manifest.local_schema) {
-      server.middlewares.use(async (req, res, next) => {
-        if (!req.url?.startsWith(server.houdiniConfig.localAPIUrl)) {
+  async configureServer(server) {
+    server.middlewares.use(async (req, res, next) => {
+      const { default: router_manifest } = await server.ssrLoadModule(
+        path_exports.join(
+          server.houdiniConfig.pluginRuntimeDirectory("houdini-react"),
+          "manifest.js"
+        )
+      );
+      try {
+        const [match] = find_match(router_manifest, req.url ?? "/");
+        if (!match) {
+          throw new Error();
+        }
+      } catch {
+        if (req.url !== localApiEndpoint(server.houdiniConfig.configFile)) {
           return next();
         }
-        let yoga;
-        if (manifest.local_yoga) {
-          const yogaPath = path_exports.join(
+      }
+      const project_manifest = await load_manifest({ config: server.houdiniConfig });
+      let schema = null;
+      if (project_manifest.local_schema) {
+        schema = (await server.ssrLoadModule(
+          path_exports.join(
             server.houdiniConfig.localApiDir,
-            "+yoga?t=" + new Date().getTime()
-          );
-          yoga = await server.ssrLoadModule(yogaPath);
-        } else {
-          const { default: schema } = await server.ssrLoadModule(
-            path_exports.join(
-              server.houdiniConfig.localApiDir,
-              "+schema?t=" + new Date().getTime()
-            )
-          );
-          const { default: createYoga } = await server.ssrLoadModule(
-            conventions_exports.render_yoga_path(server.houdiniConfig) + "?t=" + new Date().getTime()
-          );
-          yoga = createYoga({
-            schema,
-            graphqlEndpoint: server.houdiniConfig.localAPIUrl,
-            landingPage: false
-          });
-        }
-        return yoga(req, res, next);
-      });
-    }
-    server.middlewares.use(houdini_auth_routes(server));
-    server.middlewares.use(render_stream(server));
-  }
-};
-var houdini_auth_routes = (server) => {
-  return async (req, res, next) => {
-    if (!req.url) {
-      return next();
-    }
-    handle_request({
-      config: server.houdiniConfig.configFile,
-      session_keys: localApiSessionKeys(server.houdiniConfig.configFile),
-      next,
-      url: req.url,
-      ...res,
-      redirect(status = 307, url) {
-        res.statusCode = status;
-        res.setHeader("location", url);
-        res.setHeader("content-length", "0");
-        return res.end();
-      },
-      get_header: res.getHeader.bind(res),
-      set_header: res.setHeader.bind(res)
+            "+schema?t=" + new Date().getTime()
+          )
+        )).default;
+      }
+      const serverAdapter = (await server.ssrLoadModule(
+        conventions_exports.server_adapter_path(server.houdiniConfig) + "?t=" + new Date().getTime()
+      )).default;
+      let yoga = null;
+      if (project_manifest.local_yoga) {
+        const yogaPath = path_exports.join(
+          server.houdiniConfig.localApiDir,
+          "+yoga?t=" + new Date().getTime()
+        );
+        yoga = await server.ssrLoadModule(yogaPath);
+      }
+      await serverAdapter({
+        schema,
+        yoga,
+        assetPrefix: "/virtual:houdini",
+        production: false,
+        manifest: router_manifest,
+        pipe: res
+      })(req, res);
     });
-  };
-};
-var render_stream = (server) => async (request, response, next) => {
-  if (!request.url) {
-    return next();
-  }
-  const { default: manifest3 } = await server.ssrLoadModule(
-    path_exports.join(server.houdiniConfig.pluginRuntimeDirectory("houdini-react"), "manifest.js")
-  );
-  const [match] = find_match(manifest3, request.url, true);
-  if (!match) {
-    return next();
   }
-  const session = get_session(
-    new Headers(request.headers),
-    localApiSessionKeys(server.houdiniConfig.configFile)
-  );
-  const { render_to_stream } = await load_render(server);
-  const cache = new Cache({ disabled: false });
-  const loaded_queries = {};
-  const loaded_artifacts = {};
-  const { pipe, injectToStream } = await render_to_stream({
-    loaded_queries,
-    loaded_artifacts,
-    url: request.url,
-    cache,
-    session,
-    userAgent: "Vite",
-    assetPrefix: "/virtual:houdini"
-  });
-  const pending_queries = Object.keys(match.documents);
-  const pending_query_names = pending_queries.filter((q) => !(q in loaded_queries)).join(",");
-  pipe?.(response);
-  const entry = `/virtual:houdini/pages/${match.id}@${pending_query_names}.jsx`;
-  injectToStream(`
-			<script>
-				window.__houdini__initial__cache__ = ${cache.serialize()};
-				window.__houdini__initial__session__ = ${JSON.stringify(session)};
-			<\/script>
-
-			<script type="module" src="/@vite/client" async=""><\/script>
-
-			<!-- add a virtual module that hydrates the client and sets up the initial pending cache -->
-			<script type="module" src="${entry}" async=""><\/script>
-		`);
 };
-async function load_render(server) {
-  return await server.ssrLoadModule(
-    conventions_exports.render_server_path(server.houdiniConfig) + "?t=" + new Date().getTime()
-  );
-}
 
 // src/plugin/index.ts
 var manifest2;
@@ -80009,7 +79748,7 @@ var hooks = async () => ({
           import_node_path2.default.join(config.projectRoot, "src", "+client")
         );
         return `${importStatement(relativePath, "client")}
-	${exportDefaultStatement("client")}
+	${exportDefaultStatement("() => client")}
 	`;
       },
       "manifest.js": ({ config, exportDefaultStatement, importStatement }) => {
@@ -80116,7 +79855,7 @@ export function useFragmentHandle(reference: { readonly "${fragmentKey}": { ${do
     if (_env) {
       return _env;
     }
-    _env = (0, import_vite2.loadEnv)("dev", config.projectRoot || ".", "");
+    _env = (0, import_vite.loadEnv)("dev", config.projectRoot || ".", "");
     return _env;
   }
 });