@warlock.js/web 5.0.0

package/CHANGELOG.md

@@ -0,0 +1,49 @@
+# Changelog
+
+All notable changes to `@warlock.js/web` are documented here.
+
+## 5.0.0 - 2026-08-25
+
+**First published release.**
+
+### Added
+
+- SSR React pages with hydration, client navigation, route metadata, shared data, and Vite integration.
+
+### Changed
+
+- The hydration runtime is packaged as its own public entry, and production/dev route wiring now resolves the packaged client manifest and stylesheets.
+
+## 4.16.0
+
+**First published release.** The package existed in the monorepo but was absent
+from the release registry, so it had never reached npm.
+
+### Added
+
+- SSR React pages served by the Warlock HTTP server. A page route is an ordinary
+  Warlock route whose handler renders React instead of returning JSON.
+- Hydration, and client-side navigation via `<Link>` — no document reload, Back
+  and Forward included.
+- React Fast Refresh in `warlock dev`, including a server render that reflects
+  the edit rather than the pre-edit module.
+- Typed links: `href(name, params, query)`; an unknown route name is a compile
+  error.
+- `revalidate()` — re-run the current route's loaders after a mutation.
+- MRR's navigation API mirrored by name (`navigateTo`, `navigateBack`,
+  `currentRoute`, `queryString`, …) without depending on that package.
+- `warlock add web` scaffolds `src/web/` and registers the connector.
+
+### Fixed
+
+- `metadata()` no longer runs when a loader rejected. It used to be called with
+  `data: undefined` while the type promised otherwise, so a metadata function
+  reading its data threw a `TypeError` that **replaced the loader's real error**
+  and pointed at the wrong file.
+- Validation reads the same query the loader reads. Stage 4 took `query` and
+  `params` from a hand-parsed URL while `body` and `headers` came from the
+  request — so `?tags=a&tags=b` reached validation as `"b"`, and a rule on
+  `filter.status` never fired because validation saw a key literally named
+  `filter[status]`.
+- `href()` emits the query grammar core actually parses; nested objects and
+  arrays are no longer destroyed by `String(value)`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Hassan Zohdy
+
+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,125 @@
+# @warlock.js/web
+
+**SSR React pages, served by the Warlock HTTP server.**
+
+Warlock is a backend platform that renders React — not a React framework with a
+server bolted on. This package adds a page layer to an existing Warlock app
+without changing what that app already is.
+
+> **A page route is an ordinary Warlock route whose handler renders React
+> instead of returning JSON.**
+
+One route table. One matcher. One middleware chain. One validation stage. One
+request context. A page and an API endpoint are the same thing up to the point
+where one returns data and the other returns a document.
+
+## Install
+
+```bash
+warlock add web
+```
+
+That installs the package, scaffolds `src/web/` with a root and one page, and
+registers the connector in `warlock.config.ts`. Pages are opt-in: a Warlock app
+is an API until you run this.
+
+## A page
+
+```tsx
+// src/web/products.page.tsx
+import type { PageLoader, PageProps } from "@warlock.js/web";
+import { productsRepository } from "app/products/repositories/products.repository";
+import { productResourceCollection } from "app/products/resources/product.resource";
+
+export const route = "/products";
+
+/**
+ * A loader IS a controller: full Warlock context, the same DI, the same guards.
+ * It returns data instead of a response — and it may mutate the response on the
+ * way past, which a server-component framework structurally cannot do.
+ */
+export const loader = (async ({ response }) => {
+  response.header("cache-control", "private, max-age=60");
+
+  return { products: productResourceCollection(await productsRepository.all()) };
+}) satisfies PageLoader;
+
+/** Server-only. Runs after the loader and receives its data. */
+export const metadata = ({ data }) => ({
+  title: "Products",
+  description: `${data.products.length} in stock`,
+});
+
+/** Runs twice — server render, then hydration. Never `async`. */
+export default function ProductsPage({ data }: PageProps<typeof loader>) {
+  return (
+    <ul>
+      {data.products.map(product => (
+        <li key={product.id}>{product.name}</li>
+      ))}
+    </ul>
+  );
+}
+```
+
+`warlock dev` serves it. `warlock build` + `warlock start` serves it in
+production.
+
+## What you get
+
+- **Server-side rendering with hydration.** Not RSC — RSC is a written non-goal.
+- **Client-side navigation.** `<Link>` swaps the page without a document reload;
+  Back and Forward included.
+- **React Fast Refresh in dev.** Edit a component, keep your state, and the
+  server renders the new output too.
+- **Typed links.** `href(name, params, query)` — an unknown route name is a
+  compile error.
+- **Loaders that are controllers.** Full request context, guards, DI, and the
+  ability to set headers, cookies and status during the render.
+- **`revalidate()`.** POST to your own API, call it, and the page's loaders
+  re-run.
+- **Return values are Resources, never models.** A model does not survive the
+  wire: it carries methods, a connector handle and every column.
+
+## The two halves of a page file
+
+| Server-only | Runs twice (server + browser) |
+|---|---|
+| `route`, `middleware`, `validation`, `loader`, `metadata` | `Layout`, `ErrorBoundary`, default `Page` |
+
+The server half is stripped before anything reaches the browser. The runs-twice
+half never receives `request` or `response` — it also executes in a browser,
+where neither exists — and is never `async`.
+
+## Where things live
+
+```
+src/web/                    app-level web layer, and a page root
+  root.tsx                  owns <html>, renders #root
+  layouts/                  shared layouts
+  middleware/
+src/app/<module>/web/       that module's own pages
+```
+
+Both are page roots. All client code lives in a `web/` folder, and nothing
+outside one may import from one — so `rm -rf src/web src/app/*/web` removes the
+page layer and leaves a working API.
+
+**`web/` means the web layer, not the browser.** Loaders and page middleware
+inside it are server code.
+
+## Requirements
+
+- `@warlock.js/core`
+- `react` and `react-dom` 19+
+- `vite` and `@vitejs/plugin-react` — dev-only, loaded lazily, optional peers
+
+## Documentation
+
+The reference application in the Warlock repository (`v5/app`) is the worked
+example: layouts, auth-gated pages, forms posting to real controllers, locale
+handling, and error boundaries.
+
+## License
+
+MIT

package/esm/build/contribution.d.mts

@@ -0,0 +1,55 @@
+import { ConnectorBuildContribution } from "@warlock.js/core";
+
+//#region ../web/src/build/contribution.d.ts
+type WebBuildOptions = {
+  /** Source directory name under the app root. Default: `"src"`. */srcDir?: string;
+  /**
+   * Absolute path to the `@warlock.js/web` package root, which holds the
+   * hydration entry (packaged as `esm/hydration/index.mjs`, with a source
+   * fallback at `src/hydration/index.ts` for this checkout).
+   *
+   * Defaults to this module's own package root, derived from `import.meta.url`
+   * at emit time. Set it explicitly when the build process loads this module
+   * through a transform that rewrites `import.meta` (e.g. a CJS config
+   * pipeline) — the derivation is the only thing here that depends on it.
+   *
+   * Derived or configured, the root is VERIFIED at emit time against
+   * `<root>/package.json`'s `name`; a root that is not `@warlock.js/web`
+   * throws {@link WebPackageRootResolutionError} rather than being guessed at.
+   */
+  webRoot?: string;
+  /**
+   * NOT SUPPORTED. The client bundle always lands at `<build.outdir>/client`,
+   * the layout the runtime half reads (`resolveHydrationClientUrl`) — the
+   * runtime does not yet consult a relocated path. Setting this option throws
+   * {@link ClientOutDirNotSupportedError}.
+   */
+  clientOutDir?: string; /** Client-build resolve aliases: specifier -> absolute path. */
+  aliases?: Record<string, string>; /** Extra package names to keep external to the client bundle. */
+  external?: string[];
+};
+/**
+ * The resolved `@warlock.js/web` root is not that package.
+ *
+ * Same posture as the manifest resolver's three named errors: a root that
+ * cannot be proven is REJECTED, never quietly
+ * repaired by walking upwards or falling back to `process.cwd()`. A wrong root
+ * would otherwise surface much later as an unintelligible Vite entry failure.
+ */
+declare class WebPackageRootResolutionError extends Error {
+  constructor(webRoot: string, reason: string, cause?: unknown);
+}
+/**
+ * Builds web's `ConnectorBuildContribution`.
+ *
+ * `generate` writes the page barrel into `ctx.productionDir` and patches
+ * esbuild; `emit` produces the client bundle esbuild cannot. The two share one
+ * closure fact — how many pages exist — because a build with zero pages must
+ * skip the client bundle rather than emit an orphan one. `generate` itself does
+ * NOT skip: the barrel and its entry import are emitted either way, so the
+ * runtime can tell a page-free web build from a build without web.
+ */
+declare function createWebBuildContribution(options?: WebBuildOptions): ConnectorBuildContribution;
+//#endregion
+export { WebBuildOptions, WebPackageRootResolutionError, createWebBuildContribution };
+//# sourceMappingURL=contribution.d.mts.map

package/esm/build/contribution.mjs

@@ -0,0 +1,132 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+//#region ../web/src/build/contribution.ts
+/**
+* Web's build-time half — the object a `WebConnector` hands to
+* `warlock build` as its `build` contribution.
+*
+* KEPT DELIBERATELY LIGHT: everything this
+* module imports statically is a type or `node:path`. The heavy halves — the
+* filesystem discovery/barrel generator, and the Vite client build — are
+* `await import(...)`ed INSIDE the hooks, so a config file that merely
+* constructs the connector never drags Vite, React or the page graph into its
+* static import graph.
+*
+* {@link WebBuildOptions} carries JSON-SERIALIZABLE VALUES ONLY (constraint
+* B): no plugin instances, no functions, no class instances. Anything heavy is
+* constructed inside a hook after that hook's dynamic import.
+*/
+function resolveClientOutDir(context) {
+	return path.resolve(context.appRoot, context.options.outdir, "client");
+}
+/**
+* `build.clientOutDir` was set.
+*
+* The production runtime hardcodes where it reads the client bundle from
+* (`<outdir>/client`, via `resolveHydrationClientUrl`) — it does not yet
+* consult the build config for a relocated path. A build that honored a
+* custom `clientOutDir` would therefore produce an artifact the runtime
+* cannot find, silently. Rejected at build start, before any work happens,
+* rather than left to surface later as a missing-bundle failure in
+* production.
+*/
+var ClientOutDirNotSupportedError = class extends Error {
+	constructor() {
+		super("\"build.clientOutDir\" is not supported: the production server reads the client bundle from its default location and does not consult this option, so a build honoring it would produce an artifact production cannot serve correctly. Remove \"build.clientOutDir\" from the build config.");
+		this.name = "ClientOutDirNotSupportedError";
+	}
+};
+/** The package name every candidate web root must declare to be one. */
+const WEB_PACKAGE_NAME = "@warlock.js/web";
+/**
+* The resolved `@warlock.js/web` root is not that package.
+*
+* Same posture as the manifest resolver's three named errors: a root that
+* cannot be proven is REJECTED, never quietly
+* repaired by walking upwards or falling back to `process.cwd()`. A wrong root
+* would otherwise surface much later as an unintelligible Vite entry failure.
+*/
+var WebPackageRootResolutionError = class extends Error {
+	constructor(webRoot, reason, cause) {
+		super(`Cannot resolve the "${WEB_PACKAGE_NAME}" package root: "${webRoot}" ${reason}. Pass \`webRoot\` explicitly in the web build options to point at the package root whose package.json declares "name": "${WEB_PACKAGE_NAME}".`, { cause });
+		this.name = "WebPackageRootResolutionError";
+	}
+};
+/**
+* Proves that `webRoot` really is the `@warlock.js/web` package root by reading
+* `<webRoot>/package.json` and matching its `name`. Returns the path unchanged.
+*/
+function assertWebPackageRoot(webRoot) {
+	const manifestPath = path.join(webRoot, "package.json");
+	let raw;
+	try {
+		raw = readFileSync(manifestPath, "utf-8");
+	} catch (error) {
+		throw new WebPackageRootResolutionError(webRoot, "has no readable package.json", error);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		throw new WebPackageRootResolutionError(webRoot, "has a package.json that is not valid JSON", error);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new WebPackageRootResolutionError(webRoot, "has a package.json whose root is not a JSON object");
+	const name = parsed.name;
+	if (name !== WEB_PACKAGE_NAME) throw new WebPackageRootResolutionError(webRoot, `declares package name ${JSON.stringify(name)}, not "${WEB_PACKAGE_NAME}"`);
+	return webRoot;
+}
+async function resolveWebPackageRoot(configured) {
+	if (configured !== void 0) return assertWebPackageRoot(path.resolve(configured));
+	const { fileURLToPath } = await import("node:url");
+	return assertWebPackageRoot(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", ".."));
+}
+/**
+* Builds web's `ConnectorBuildContribution`.
+*
+* `generate` writes the page barrel into `ctx.productionDir` and patches
+* esbuild; `emit` produces the client bundle esbuild cannot. The two share one
+* closure fact — how many pages exist — because a build with zero pages must
+* skip the client bundle rather than emit an orphan one. `generate` itself does
+* NOT skip: the barrel and its entry import are emitted either way, so the
+* runtime can tell a page-free web build from a build without web.
+*/
+function createWebBuildContribution(options = {}) {
+	if (options.clientOutDir !== void 0) throw new ClientOutDirNotSupportedError();
+	let pageCount = 0;
+	return {
+		async generate(context) {
+			const { generatePagesBarrel, WEB_ENTRY_IMPORT, WEB_ESBUILD_PATCH } = await import("./generate-pages-barrel.mjs");
+			pageCount = (await generatePagesBarrel({
+				appRoot: context.appRoot,
+				productionDir: context.productionDir,
+				srcDir: options.srcDir,
+				clientDir: path.relative(context.appRoot, resolveClientOutDir(context)).split(path.sep).join("/")
+			})).pageCount;
+			return {
+				entryImports: [WEB_ENTRY_IMPORT],
+				esbuild: WEB_ESBUILD_PATCH
+			};
+		},
+		async emit(context) {
+			if (pageCount === 0) return;
+			const { buildWarlockHydrationClient } = await import("../vite/index.mjs");
+			const { appConventionAliases } = await import("../vite/app-convention-aliases.mjs");
+			const callerAliases = Object.entries(options.aliases ?? {}).map(([find, replacement]) => ({
+				find,
+				replacement
+			}));
+			await buildWarlockHydrationClient({
+				appRoot: context.appRoot,
+				webRoot: await resolveWebPackageRoot(options.webRoot),
+				outDir: resolveClientOutDir(context),
+				resolveAliases: [...callerAliases, ...appConventionAliases(path.join(context.appRoot, options.srcDir ?? "src"))],
+				external: options.external
+			});
+		}
+	};
+}
+
+//#endregion
+export { WebPackageRootResolutionError, createWebBuildContribution, resolveWebPackageRoot };
+//# sourceMappingURL=contribution.mjs.map

package/esm/build/contribution.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contribution.mjs","names":[],"sources":["../../../../../../../web/src/build/contribution.ts"],"sourcesContent":["/**\n * Web's build-time half — the object a `WebConnector` hands to\n * `warlock build` as its `build` contribution.\n *\n * KEPT DELIBERATELY LIGHT: everything this\n * module imports statically is a type or `node:path`. The heavy halves — the\n * filesystem discovery/barrel generator, and the Vite client build — are\n * `await import(...)`ed INSIDE the hooks, so a config file that merely\n * constructs the connector never drags Vite, React or the page graph into its\n * static import graph.\n *\n * {@link WebBuildOptions} carries JSON-SERIALIZABLE VALUES ONLY (constraint\n * B): no plugin instances, no functions, no class instances. Anything heavy is\n * constructed inside a hook after that hook's dynamic import.\n */\nimport { readFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport type {\n  ConnectorBuildContext,\n  ConnectorBuildContribution,\n  ConnectorBuildGenerateResult,\n} from \"@warlock.js/core\";\n\nexport type WebBuildOptions = {\n  /** Source directory name under the app root. Default: `\"src\"`. */\n  srcDir?: string;\n  /**\n   * Absolute path to the `@warlock.js/web` package root, which holds the\n   * hydration entry (packaged as `esm/hydration/index.mjs`, with a source\n   * fallback at `src/hydration/index.ts` for this checkout).\n   *\n   * Defaults to this module's own package root, derived from `import.meta.url`\n   * at emit time. Set it explicitly when the build process loads this module\n   * through a transform that rewrites `import.meta` (e.g. a CJS config\n   * pipeline) — the derivation is the only thing here that depends on it.\n   *\n   * Derived or configured, the root is VERIFIED at emit time against\n   * `<root>/package.json`'s `name`; a root that is not `@warlock.js/web`\n   * throws {@link WebPackageRootResolutionError} rather than being guessed at.\n   */\n  webRoot?: string;\n  /**\n   * NOT SUPPORTED. The client bundle always lands at `<build.outdir>/client`,\n   * the layout the runtime half reads (`resolveHydrationClientUrl`) — the\n   * runtime does not yet consult a relocated path. Setting this option throws\n   * {@link ClientOutDirNotSupportedError}.\n   */\n  clientOutDir?: string;\n  /** Client-build resolve aliases: specifier -> absolute path. */\n  aliases?: Record<string, string>;\n  /** Extra package names to keep external to the client bundle. */\n  external?: string[];\n};\n\nfunction resolveClientOutDir(context: ConnectorBuildContext): string {\n  return path.resolve(context.appRoot, context.options.outdir, \"client\");\n}\n\n/**\n * `build.clientOutDir` was set.\n *\n * The production runtime hardcodes where it reads the client bundle from\n * (`<outdir>/client`, via `resolveHydrationClientUrl`) — it does not yet\n * consult the build config for a relocated path. A build that honored a\n * custom `clientOutDir` would therefore produce an artifact the runtime\n * cannot find, silently. Rejected at build start, before any work happens,\n * rather than left to surface later as a missing-bundle failure in\n * production.\n */\nexport class ClientOutDirNotSupportedError extends Error {\n  public constructor() {\n    super(\n      '\"build.clientOutDir\" is not supported: the production server reads the client bundle ' +\n        \"from its default location and does not consult this option, so a build honoring it \" +\n        \"would produce an artifact production cannot serve correctly. Remove \" +\n        '\"build.clientOutDir\" from the build config.',\n    );\n    this.name = \"ClientOutDirNotSupportedError\";\n  }\n}\n\n/** The package name every candidate web root must declare to be one. */\nconst WEB_PACKAGE_NAME = \"@warlock.js/web\";\n\n/**\n * The resolved `@warlock.js/web` root is not that package.\n *\n * Same posture as the manifest resolver's three named errors: a root that\n * cannot be proven is REJECTED, never quietly\n * repaired by walking upwards or falling back to `process.cwd()`. A wrong root\n * would otherwise surface much later as an unintelligible Vite entry failure.\n */\nexport class WebPackageRootResolutionError extends Error {\n  public constructor(webRoot: string, reason: string, cause?: unknown) {\n    super(\n      `Cannot resolve the \"${WEB_PACKAGE_NAME}\" package root: \"${webRoot}\" ${reason}. ` +\n        \"Pass `webRoot` explicitly in the web build options to point at the package root \" +\n        `whose package.json declares \"name\": \"${WEB_PACKAGE_NAME}\".`,\n      { cause },\n    );\n    this.name = \"WebPackageRootResolutionError\";\n  }\n}\n\n/**\n * Proves that `webRoot` really is the `@warlock.js/web` package root by reading\n * `<webRoot>/package.json` and matching its `name`. Returns the path unchanged.\n */\nexport function assertWebPackageRoot(webRoot: string): string {\n  const manifestPath = path.join(webRoot, \"package.json\");\n\n  let raw: string;\n\n  try {\n    raw = readFileSync(manifestPath, \"utf-8\");\n  } catch (error) {\n    throw new WebPackageRootResolutionError(webRoot, \"has no readable package.json\", error);\n  }\n\n  let parsed: unknown;\n\n  try {\n    parsed = JSON.parse(raw);\n  } catch (error) {\n    throw new WebPackageRootResolutionError(\n      webRoot,\n      \"has a package.json that is not valid JSON\",\n      error,\n    );\n  }\n\n  if (typeof parsed !== \"object\" || parsed === null || Array.isArray(parsed)) {\n    throw new WebPackageRootResolutionError(\n      webRoot,\n      \"has a package.json whose root is not a JSON object\",\n    );\n  }\n\n  const name = (parsed as { name?: unknown }).name;\n\n  if (name !== WEB_PACKAGE_NAME) {\n    throw new WebPackageRootResolutionError(\n      webRoot,\n      `declares package name ${JSON.stringify(name)}, not \"${WEB_PACKAGE_NAME}\"`,\n    );\n  }\n\n  return webRoot;\n}\n\nexport async function resolveWebPackageRoot(configured: string | undefined): Promise<string> {\n  if (configured !== undefined) {\n    return assertWebPackageRoot(path.resolve(configured));\n  }\n\n  const { fileURLToPath } = await import(\"node:url\");\n\n  // `web/src/build/contribution.ts` published as `web/esm/build/contribution.js`\n  // — two levels up is the package root under both layouts.\n  return assertWebPackageRoot(\n    path.resolve(path.dirname(fileURLToPath(import.meta.url)), \"..\", \"..\"),\n  );\n}\n\n/**\n * Builds web's `ConnectorBuildContribution`.\n *\n * `generate` writes the page barrel into `ctx.productionDir` and patches\n * esbuild; `emit` produces the client bundle esbuild cannot. The two share one\n * closure fact — how many pages exist — because a build with zero pages must\n * skip the client bundle rather than emit an orphan one. `generate` itself does\n * NOT skip: the barrel and its entry import are emitted either way, so the\n * runtime can tell a page-free web build from a build without web.\n */\nexport function createWebBuildContribution(\n  options: WebBuildOptions = {},\n): ConnectorBuildContribution {\n  if (options.clientOutDir !== undefined) {\n    throw new ClientOutDirNotSupportedError();\n  }\n\n  let pageCount = 0;\n\n  return {\n    async generate(context: ConnectorBuildContext): Promise<ConnectorBuildGenerateResult | void> {\n      const { generatePagesBarrel, WEB_ENTRY_IMPORT, WEB_ESBUILD_PATCH } = await import(\n        \"./generate-pages-barrel\"\n      );\n\n      const result = await generatePagesBarrel({\n        appRoot: context.appRoot,\n        productionDir: context.productionDir,\n        srcDir: options.srcDir,\n        // Derived from `resolveClientOutDir` — the SAME function `emit` passes\n        // to the Vite build below — so the path baked into the manifest and\n        // the path the bundle is written to are one expression, not two that\n        // happen to agree today.\n        // POSIX-normalised inline rather than via the generator's `toPosix`:\n        // this module's static graph is `node:path` and types only, and the\n        // generator is reached by `await import` precisely to keep it that way.\n        clientDir: path\n          .relative(context.appRoot, resolveClientOutDir(context))\n          .split(path.sep)\n          .join(\"/\"),\n      });\n\n      pageCount = result.pageCount;\n\n      // Contributed unconditionally, zero pages included: the barrel is always\n      // written, and the entry has to IMPORT it for the empty table to reach\n      // the runtime. Withholding this line on zero pages would leave the\n      // manifest absent, which is the runtime's signal for \"never built with\n      // web\" — the exact confusion the always-written barrel removes.\n      return { entryImports: [WEB_ENTRY_IMPORT], esbuild: WEB_ESBUILD_PATCH };\n    },\n\n    async emit(context: ConnectorBuildContext): Promise<void> {\n      if (pageCount === 0) {\n        return;\n      }\n\n      const { buildWarlockHydrationClient } = await import(\"../vite\");\n      const { appConventionAliases } = await import(\"../vite/app-convention-aliases\");\n\n      // The app-tree convention (`web/*`, `app/*`) the dev server installs must\n      // also reach the production build, from the SAME definition — see\n      // `app-convention-aliases.ts`. Caller-supplied aliases come first so a\n      // caller can win a conflict, matching the dev server's ordering.\n      const callerAliases = Object.entries(options.aliases ?? {}).map(([find, replacement]) => ({\n        find,\n        replacement,\n      }));\n\n      await buildWarlockHydrationClient({\n        appRoot: context.appRoot,\n        webRoot: await resolveWebPackageRoot(options.webRoot),\n        outDir: resolveClientOutDir(context),\n        resolveAliases: [\n          ...callerAliases,\n          ...appConventionAliases(path.join(context.appRoot, options.srcDir ?? \"src\")),\n        ],\n        external: options.external,\n      });\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAsDA,SAAS,oBAAoB,SAAwC;CACnE,OAAO,KAAK,QAAQ,QAAQ,SAAS,QAAQ,QAAQ,QAAQ,QAAQ;AACvE;;;;;;;;;;;;AAaA,IAAa,gCAAb,cAAmD,MAAM;CACvD,AAAO,cAAc;EACnB,MACE,6RAIF;EACA,KAAK,OAAO;CACd;AACF;;AAGA,MAAM,mBAAmB;;;;;;;;;AAUzB,IAAa,gCAAb,cAAmD,MAAM;CACvD,AAAO,YAAY,SAAiB,QAAgB,OAAiB;EACnE,MACE,uBAAuB,iBAAiB,mBAAmB,QAAQ,IAAI,OAAO,2HAEpC,iBAAiB,KAC3D,EAAE,MAAM,CACV;EACA,KAAK,OAAO;CACd;AACF;;;;;AAMA,SAAgB,qBAAqB,SAAyB;CAC5D,MAAM,eAAe,KAAK,KAAK,SAAS,cAAc;CAEtD,IAAI;CAEJ,IAAI;EACF,MAAM,aAAa,cAAc,OAAO;CAC1C,SAAS,OAAO;EACd,MAAM,IAAI,8BAA8B,SAAS,gCAAgC,KAAK;CACxF;CAEA,IAAI;CAEJ,IAAI;EACF,SAAS,KAAK,MAAM,GAAG;CACzB,SAAS,OAAO;EACd,MAAM,IAAI,8BACR,SACA,6CACA,KACF;CACF;CAEA,IAAI,OAAO,WAAW,YAAY,WAAW,QAAQ,MAAM,QAAQ,MAAM,GACvE,MAAM,IAAI,8BACR,SACA,oDACF;CAGF,MAAM,OAAQ,OAA8B;CAE5C,IAAI,SAAS,kBACX,MAAM,IAAI,8BACR,SACA,yBAAyB,KAAK,UAAU,IAAI,EAAE,SAAS,iBAAiB,EAC1E;CAGF,OAAO;AACT;AAEA,eAAsB,sBAAsB,YAAiD;CAC3F,IAAI,eAAe,QACjB,OAAO,qBAAqB,KAAK,QAAQ,UAAU,CAAC;CAGtD,MAAM,EAAE,kBAAkB,MAAM,OAAO;CAIvC,OAAO,qBACL,KAAK,QAAQ,KAAK,QAAQ,cAAc,OAAO,KAAK,GAAG,CAAC,GAAG,MAAM,IAAI,CACvE;AACF;;;;;;;;;;;AAYA,SAAgB,2BACd,UAA2B,CAAC,GACA;CAC5B,IAAI,QAAQ,iBAAiB,QAC3B,MAAM,IAAI,8BAA8B;CAG1C,IAAI,YAAY;CAEhB,OAAO;EACL,MAAM,SAAS,SAA8E;GAC3F,MAAM,EAAE,qBAAqB,kBAAkB,sBAAsB,MAAM,OACzE;GAoBF,aAAY,MAjBS,oBAAoB;IACvC,SAAS,QAAQ;IACjB,eAAe,QAAQ;IACvB,QAAQ,QAAQ;IAQhB,WAAW,KACR,SAAS,QAAQ,SAAS,oBAAoB,OAAO,CAAC,CAAC,CACvD,MAAM,KAAK,GAAG,CAAC,CACf,KAAK,GAAG;GACb,CAAC,EAEiB,CAAC;GAOnB,OAAO;IAAE,cAAc,CAAC,gBAAgB;IAAG,SAAS;GAAkB;EACxE;EAEA,MAAM,KAAK,SAA+C;GACxD,IAAI,cAAc,GAChB;GAGF,MAAM,EAAE,gCAAgC,MAAM,OAAO;GACrD,MAAM,EAAE,yBAAyB,MAAM,OAAO;GAM9C,MAAM,gBAAgB,OAAO,QAAQ,QAAQ,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,kBAAkB;IACxF;IACA;GACF,EAAE;GAEF,MAAM,4BAA4B;IAChC,SAAS,QAAQ;IACjB,SAAS,MAAM,sBAAsB,QAAQ,OAAO;IACpD,QAAQ,oBAAoB,OAAO;IACnC,gBAAgB,CACd,GAAG,eACH,GAAG,qBAAqB,KAAK,KAAK,QAAQ,SAAS,QAAQ,UAAU,KAAK,CAAC,CAC7E;IACA,UAAU,QAAQ;GACpB,CAAC;EACH;CACF;AACF"}