@pyreon/zero 0.13.1 → 0.15.0

package/src/types.ts

@@ -1,7 +1,17 @@
 import type { ComponentFn } from '@pyreon/core'
-import type { NavigationGuard } from '@pyreon/router'
+import type { LoaderContext, NavigationGuard } from '@pyreon/router'
 import type { Middleware } from '@pyreon/server'
 
+// Re-export router's `LoaderContext` so consumers importing it from
+// `@pyreon/zero` keep working. The previous duplicate `interface
+// LoaderContext` (with a `request: Request` field that was never
+// populated by the actually-constructed runtime ctx) was a
+// typed-but-unimplemented bug class — caught by `audit-types`. If
+// SSR loaders need access to the request, plumb it through the
+// router-level `LoaderContext` in a follow-up PR; do NOT add fields
+// here that the runtime doesn't populate.
+export type { LoaderContext }
+
 // ─── Route module conventions ────────────────────────────────────────────────
 
 /** What a route file (e.g. `src/routes/index.tsx`) can export. */
@@ -26,14 +36,6 @@ export interface RouteModule {
   renderMode?: RenderMode
 }
 
-/** Context passed to route loaders. */
-export interface LoaderContext {
-  params: Record<string, string>
-  query: Record<string, string>
-  signal: AbortSignal
-  request: Request
-}
-
 /** Per-route metadata. */
 export interface RouteMeta {
   title?: string
@@ -116,6 +118,23 @@ export interface RouteFileExports {
   hasError: boolean
   /** Has `export const middleware` */
   hasMiddleware: boolean
+  /**
+   * Has `export const loaderKey` or `export function loaderKey`. When present,
+   * the route generator wires it as the `loaderKey` field on the route record,
+   * which controls cache identity for `_loaderCache`. Useful for auth-gate
+   * loaders that should invalidate when the session cookie changes — read
+   * `document.cookie` (CSR) or `ctx.request.headers.get('cookie')` (SSR) and
+   * derive a key from session identity. Default cache key is `path + params`,
+   * which doesn't see cookie changes.
+   */
+  hasLoaderKey: boolean
+  /**
+   * Has `export const gcTime` (number, in ms). When present, the route generator
+   * inlines it on the route record. `gcTime: 0` disables caching entirely —
+   * the loader runs on every navigation. Useful for auth-gate loaders that
+   * must validate session on every navigation rather than serve stale data.
+   */
+  hasGcTime: boolean
   /**
    * Raw text of the `export const meta = …` initializer, captured as a
    * literal expression. When present, the route generator inlines this

package/src/vite-plugin.ts

@@ -1,9 +1,19 @@
 import { readFile } from 'node:fs/promises'
 import { existsSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
+import { Readable } from 'node:stream'
 import type { Plugin, ViteDevServer } from 'vite'
-import { generateApiRouteModule } from './api-routes'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { ApiRouteEntry } from './api-routes'
+import {
+  createApiMiddleware,
+  generateApiRouteModule,
+  matchApiRoute,
+} from './api-routes'
 import { resolveConfig } from './config'
+// Used in the dev-mode SSR catch handler to convert loader-thrown
+// `redirect()` errors into real HTTP redirects (302/307/308).
+import { getRedirectInfo } from '@pyreon/router'
 
 /**
  * Scan node_modules/@pyreon/ to discover all installed Pyreon packages.
@@ -45,6 +55,7 @@ import {
 	scanRouteFilesWithExports,
 } from "./fs-router";
 import { render404Page } from "./not-found";
+import { ssgPlugin } from "./ssg-plugin";
 import type { ZeroConfig } from "./types";
 
 const VIRTUAL_ROUTES_ID = "virtual:zero/routes";
@@ -69,12 +80,12 @@ const RESOLVED_VIRTUAL_API_ROUTES_ID = `\0${VIRTUAL_API_ROUTES_ID}`;
  *   plugins: [pyreon(), zero()],
  * }
  */
-export function zeroPlugin(userConfig: ZeroConfig = {}): Plugin {
+export function zeroPlugin(userConfig: ZeroConfig = {}): Plugin[] {
 	const config = resolveConfig(userConfig);
 	let routesDir: string;
 	let root: string;
 
-	const plugin: Plugin & { _zeroConfig: ZeroConfig } = {
+	const mainPlugin: Plugin & { _zeroConfig: ZeroConfig } = {
 		name: "pyreon-zero",
 		enforce: "pre",
 		_zeroConfig: userConfig,
@@ -127,6 +138,35 @@ export function zeroPlugin(userConfig: ZeroConfig = {}): Plugin {
 		},
 
 		configureServer(server) {
+			// Dev-mode API-route middleware — production wires `createApiMiddleware`
+			// via `createServer`, but dev had no equivalent. API requests fell
+			// through to Vite's default 404. This middleware loads the
+			// `virtual:zero/api-routes` module and dispatches matching requests to
+			// the route's `GET()` / `POST()` / etc. handler. Mirrors the production
+			// flow in `entry-server.ts` minus the ergonomic helpers (auth, cors,
+			// etc. — those plug in via user-defined Pyreon middleware which dev
+			// doesn't currently load; not in scope here).
+			//
+			// Registered FIRST so API requests don't get SSR'd or 404'd.
+			server.middlewares.use((req, res, next) => {
+				const pathname = req.url?.split("?")[0] ?? "/";
+				if (pathname.startsWith("/@") || pathname.startsWith("/__"))
+					return next();
+				// Skip files (extension-bearing) — let Vite's static pipeline serve.
+				if (/\.\w+$/.test(pathname)) return next();
+
+				dispatchApiRoute(server, req, res).then(
+					(handled) => {
+						if (!handled) next();
+					},
+					(err: unknown) => {
+						// oxlint-disable-next-line no-console
+						console.error("[Pyreon] Error in dev API dispatcher:", err);
+						next();
+					},
+				);
+			});
+
 			// Dev-mode SSR middleware — for mode: "ssr", actually render each
 			// matched route server-side instead of serving the SPA shell.
 			// Runs BEFORE the 404 handler so matched routes are SSR'd and
@@ -141,7 +181,26 @@ export function zeroPlugin(userConfig: ZeroConfig = {}): Plugin {
 						return next();
 					if (/\.\w+$/.test(pathname)) return next();
 
-					renderSsr(server, root, req.originalUrl ?? pathname, pathname).then(
+					// Build a Web Request from the Node IncomingMessage so loaders
+					// can read cookies / auth headers via `ctx.request` and call
+					// `redirect()` from a server-side context.
+					const reqHost = req.headers.host ?? "localhost";
+					const reqUrl = new URL(req.url ?? "/", `http://${reqHost}`);
+					const reqHeaders = new Headers();
+					for (const [key, value] of Object.entries(req.headers)) {
+						if (value !== undefined) {
+							reqHeaders.set(
+								key,
+								Array.isArray(value) ? value.join(", ") : String(value),
+							);
+						}
+					}
+					const webReq = new Request(reqUrl.href, {
+						method: req.method ?? "GET",
+						headers: reqHeaders,
+					});
+
+					renderSsr(server, root, req.originalUrl ?? pathname, pathname, webReq).then(
 						(result) => {
 							if (result === null) return next();
 							res.statusCode = 200;
@@ -150,6 +209,16 @@ export function zeroPlugin(userConfig: ZeroConfig = {}): Plugin {
 							res.end(result);
 						},
 						(err: unknown) => {
+							// Loader-thrown `redirect()` — convert to a real HTTP redirect
+							// (302/307/308) BEFORE the layout renders. This is the dev-mode
+							// equivalent of the production handler's redirect catch.
+							const info = getRedirectInfo(err);
+							if (info) {
+								res.statusCode = info.status;
+								res.setHeader("Location", info.url);
+								res.end();
+								return;
+							}
 							const error = err instanceof Error ? err : new Error(String(err));
 							server.ssrFixStacktrace(error);
 							const html = renderErrorOverlay(error);
@@ -254,11 +323,11 @@ export function zeroPlugin(userConfig: ZeroConfig = {}): Plugin {
 			});
 		},
 
-		config(userConfig) {
+		config(viteUserConfig) {
 			// Discover all @pyreon/* packages installed in node_modules.
 			// The "bun" export condition points to TS source — esbuild's
 			// dep optimizer would compile them with the wrong JSX runtime.
-			const root = userConfig.root ?? process.cwd()
+			const root = viteUserConfig.root ?? process.cwd()
 			const pyreonExclude = scanPyreonPackages(root)
 
 			// `@pyreon/runtime-server` is only imported by zero's dev SSR
@@ -292,9 +361,16 @@ export function zeroPlugin(userConfig: ZeroConfig = {}): Plugin {
 				optimizeDeps: {
 					exclude: pyreonExclude,
 				},
-				server: {
-					port: config.port,
-				},
+				// Only set the port when the user explicitly provided one in
+				// `zero({ port: N })`. Without this guard, the plugin always
+				// returned `server: { port: 3000 }` which overrode Vite's CLI
+				// `--port` flag and made multi-example dev impossible — every
+				// example tried to bind 3000 even when launched with
+				// `vite --port 5173`. Surfaced when wiring up the playwright
+				// e2e suite.
+				...(userConfig.port !== undefined
+					? { server: { port: config.port } }
+					: {}),
 				define: {
 					__ZERO_MODE__: JSON.stringify(config.mode),
 					__ZERO_BASE__: JSON.stringify(config.base),
@@ -303,7 +379,112 @@ export function zeroPlugin(userConfig: ZeroConfig = {}): Plugin {
 		},
 	};
 
-	return plugin;
+	// SSG mode auto-wires the static-site generation hook. Other modes get
+	// just the main plugin. The SSG plugin internally no-ops when
+	// `mode !== 'ssg'`, but skipping it entirely keeps the plugin chain
+	// minimal for SSR/SPA/ISR builds (one less `closeBundle` to call).
+	return config.mode === "ssg" ? [mainPlugin, ssgPlugin(userConfig)] : [mainPlugin];
+}
+
+/**
+ * Dev-mode API-route dispatcher. Loads the `virtual:zero/api-routes` virtual
+ * module, builds a Web `Request` from the Node `IncomingMessage`, and invokes
+ * the matching route's HTTP-method handler.
+ *
+ * Returns `true` if the API middleware handled the request (response written).
+ * Returns `false` if no route matched (caller falls through to next middleware).
+ *
+ * Mirrors what `createServer` wires up in production via `createApiMiddleware`,
+ * but adapted for Vite's connect-style middleware stack — needs a Node→Web
+ * request adapter.
+ */
+async function dispatchApiRoute(
+	server: ViteDevServer,
+	req: IncomingMessage,
+	res: ServerResponse,
+): Promise<boolean> {
+	let apiRoutes: ApiRouteEntry[];
+	try {
+		const mod = await server.ssrLoadModule(VIRTUAL_API_ROUTES_ID);
+		apiRoutes = (mod.apiRoutes ?? []) as ApiRouteEntry[];
+	} catch {
+		return false;
+	}
+	if (apiRoutes.length === 0) return false;
+
+	const host = req.headers.host ?? "localhost";
+	const url = new URL(req.url ?? "/", `http://${host}`);
+	const pathname = url.pathname;
+
+	// Quick gate: only build the Web Request when the path actually matches
+	// an api route. Reuses the same `matchApiRoute` that `createApiMiddleware`
+	// uses internally — including catch-all `:param*` patterns from
+	// `[...slug].ts` API routes — so the gate and the dispatcher agree on
+	// what counts as a match. Avoids per-request body buffering for SSR /
+	// static traffic that doesn't target an API route.
+	const anyMatch = apiRoutes.some((r) => matchApiRoute(r.pattern, pathname) !== null);
+	if (!anyMatch) return false;
+
+	// Convert Node IncomingMessage → Web Request. Stream the request body
+	// for non-GET/HEAD via `Readable.toWeb` instead of buffering — large
+	// uploads (multipart, file POSTs) don't have to fit in memory before
+	// the handler sees them. `duplex: 'half'` is required by the WHATWG
+	// fetch spec when `body` is a `ReadableStream`.
+	const method = (req.method ?? "GET").toUpperCase();
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(req.headers)) {
+		if (value !== undefined) {
+			headers.set(key, Array.isArray(value) ? value.join(", ") : String(value));
+		}
+	}
+	const requestInit: RequestInit & { duplex?: "half" } = { method, headers };
+	if (method !== "GET" && method !== "HEAD") {
+		// `Readable.toWeb` returns Node's `node:stream/web` `ReadableStream`;
+		// `RequestInit.body` expects the DOM `ReadableStream`. They're
+		// structurally identical at runtime but TS keeps them as separate
+		// types — `as unknown as` is the standard bridge per TS's own
+		// "convert to unknown first" suggestion.
+		requestInit.body = Readable.toWeb(req) as unknown as ReadableStream<Uint8Array>;
+		requestInit.duplex = "half";
+	}
+	const webReq = new Request(url.href, requestInit);
+
+	const middleware = createApiMiddleware(apiRoutes);
+	const response = await middleware({
+		req: webReq,
+		url,
+		path: pathname + url.search,
+		headers: new Headers(),
+		locals: {},
+	});
+
+	if (!response) return false;
+
+	// Pipe the Web Response body directly to the Node response stream
+	// instead of buffering with `arrayBuffer()`. Critical for SSE, large
+	// downloads, and any handler that returns a `Response` constructed
+	// from a streaming source — buffering would defeat the streaming
+	// contract and OOM on large payloads.
+	res.statusCode = response.status;
+	response.headers.forEach((v, k) => {
+		res.setHeader(k, v);
+	});
+	if (response.body) {
+		// `pipe(res)` ends `res` automatically on stream completion and
+		// auto-cancels the upstream Web ReadableStream if the client
+		// disconnects (Node ≥18). We don't await — once the headers and
+		// pipe are wired, the function's job is done. The connect chain
+		// doesn't call `next()` because we resolved with `true`.
+		// `response.body` is a DOM `ReadableStream`; `Readable.fromWeb`
+		// expects `node:stream/web`'s `ReadableStream`. Cross-realm types
+		// don't unify in TS — bridge via `unknown` per TS's own guidance.
+		Readable.fromWeb(
+			response.body as unknown as import("node:stream/web").ReadableStream,
+		).pipe(res);
+	} else {
+		res.end();
+	}
+	return true;
 }
 
 /**
@@ -359,6 +540,7 @@ async function renderSsr(
 	root: string,
 	originalUrl: string,
 	pathname: string,
+	req?: Request,
 ): Promise<string | null> {
 	// Pattern check FIRST — otherwise SSR would try (and likely crash) on
 	// asset paths that happened to accept text/html (e.g. curl-style).
@@ -403,25 +585,19 @@ async function renderSsr(
 		],
 	);
 
-	// Build the SAME app tree the client will hydrate against. `entry-client`
-	// imports `layout` from `_layout.tsx` and passes it explicitly to
-	// `startClient` → `createApp`. We mirror that here: discover the user's
-	// `_layout` (if present) via Vite's SSR module graph and pass it along.
-	// Without this, SSR renders a different tree (no outer Layout wrapper)
-	// and hydration mismatches at the very first nesting level — cascading
-	// into duplicated mounts of every section below.
-	let userLayout: unknown
-	for (const ext of ['tsx', 'ts', 'jsx', 'js']) {
-		try {
-			const layoutMod = (await server.ssrLoadModule(
-				`/src/routes/_layout.${ext}`,
-			)) as { layout?: unknown; default?: unknown }
-			userLayout = layoutMod.layout ?? layoutMod.default
-			if (userLayout) break
-		} catch {
-			// Try the next extension. If none exist, createApp uses DefaultLayout.
-		}
-	}
+	// Don't auto-load `_layout.tsx` as the outer Layout. fs-router already
+	// emits it as a parent route in the matched chain — wrapping createApp
+	// with the same layout AGAIN produced a double mount: the App tree was
+	// `<Layout><RouterView/></Layout>` AND the router's first matched
+	// record was the layout, rendering it a second time inside RouterView.
+	// Symptom: duplicate `<nav>`, duplicate `<div id="layout">`,
+	// hydration mismatches, strict-mode locator violations in playwright.
+	//
+	// If a user genuinely needs an outer wrapper that sits ABOVE the
+	// router (e.g. a global provider not tied to any route), they can
+	// still pass it via `startClient({ layout })` — but the file should
+	// NOT live under `src/routes/_layout.{ts,tsx,…}` (which fs-router
+	// always treats as a parent route).
 
 	// Use zero's own `createApp` rather than reassembling the tree by hand —
 	// guarantees server and client agree on every wrapper component (any
@@ -435,20 +611,16 @@ async function renderSsr(
 	const appMod = (await server.ssrLoadModule(
 		"@pyreon/zero/server",
 	)) as typeof import("./server")
-	type CreateAppLayout = NonNullable<
-		Parameters<typeof appMod.createApp>[0]["layout"]
-	>
 	const { App, router: routerInst } = appMod.createApp({
 		routes: routes as import("@pyreon/router").RouteRecord[],
 		routerMode: "history",
 		url: pathname,
-		...(userLayout ? { layout: userLayout as CreateAppLayout } : {}),
 	})
 
 	// `preload` loads lazy route components AND runs loaders for `pathname` so
 	// the synchronous render pass produces final HTML — no loading fallbacks,
 	// no `useLoaderData() === undefined`.
-	await routerInst.preload(pathname);
+	await routerInst.preload(pathname, req);
 
 	return runtimeServer.runWithRequestContext(async () => {
 		const app = core.h(App as Parameters<typeof core.h>[0], null);
@@ -469,22 +641,30 @@ async function renderSsr(
 	});
 }
 
-/** Extract all URL patterns from a nested route tree. */
+/**
+ * Extract all URL patterns from a nested route tree.
+ *
+ * The fs-router emits ABSOLUTE paths for every route, including grandchildren —
+ * `{ path: "/app/dashboard" }` not `{ path: "dashboard" }`. The matcher reads
+ * each route's `path` as-is; no prefix accumulation. Pre-fix, this function
+ * concatenated `${prefix}${route.path}` which produced patterns like
+ * `///app/app/dashboard` (prefix `'/app'` + path `'/app/dashboard'`). After
+ * `path.split('/').filter(Boolean)` those became `['app', 'app', 'dashboard']`
+ * — which can't match a real `/app/dashboard` request — so dev-server returned
+ * 404 for every nested-layout route. Re-enables PR #411 specs that rely on
+ * `/app/*` routing.
+ */
 function flattenRoutePatterns(
 	routes: Array<{ path?: string; children?: unknown[] }>,
-	prefix = "",
 ): string[] {
 	const patterns: string[] = [];
 	for (const route of routes) {
 		if (!route.path) continue;
-		const fullPath =
-			route.path === "/" && prefix ? prefix : `${prefix}${route.path}`;
-		patterns.push(fullPath);
+		patterns.push(route.path);
 		if (route.children) {
 			patterns.push(
 				...flattenRoutePatterns(
 					route.children as Array<{ path?: string; children?: unknown[] }>,
-					fullPath,
 				),
 			);
 		}

package/lib/actions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"actions.js","names":[],"sources":["../src/actions.ts"],"sourcesContent":["import type { MiddlewareContext } from '@pyreon/server'\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\n/** Context passed to server action handlers. */\nexport interface ActionContext {\n  /** The original request. */\n  request: Request\n  /** Parsed form data (for form submissions). */\n  formData: FormData | null\n  /** Parsed JSON body (for JSON submissions). */\n  json: unknown\n  /** Request headers. */\n  headers: Headers\n}\n\n/** A server action handler function. */\nexport type ActionHandler<T = unknown> = (ctx: ActionContext) => T | Promise<T>\n\n/** A registered action with its ID and handler. */\ninterface RegisteredAction {\n  id: string\n  handler: ActionHandler\n}\n\n/** Client-side callable action returned by defineAction. */\nexport interface Action<T = unknown> {\n  /** Call the action with JSON data. */\n  (data?: unknown): Promise<T>\n  /** The action's unique ID. */\n  actionId: string\n}\n\n// ─── Registry ────────────────────────────────────────────────────────────────\n\nconst actionRegistry = new Map<string, RegisteredAction>()\n\n/**\n * Define a server action. Returns a callable function that:\n * - On the **client**: sends a POST request to `/_zero/actions/<id>`\n * - On the **server** (SSR): executes the handler directly (no fetch)\n *\n * @example\n * // In a route file or module:\n * export const createPost = defineAction(async (ctx) => {\n *   const data = ctx.json as { title: string; body: string }\n *   // ... save to database\n *   return { success: true, id: 123 }\n * })\n *\n * // In a component:\n * const result = await createPost({ title: 'Hello', body: '...' })\n */\nexport function defineAction<T = unknown>(handler: ActionHandler<T>): Action<T> {\n  const id = `action_${crypto.randomUUID().slice(0, 8)}`\n\n  actionRegistry.set(id, { id, handler: handler as ActionHandler })\n\n  const callable = async (data?: unknown): Promise<T> => {\n    // Server-side: execute handler directly (no network round-trip)\n    if (typeof globalThis.window === 'undefined') {\n      return handler({\n        request: new Request(`http://localhost/_zero/actions/${id}`, {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify(data ?? null),\n        }),\n        formData: null,\n        json: data ?? null,\n        headers: new Headers({ 'Content-Type': 'application/json' }),\n      })\n    }\n\n    // Client-side: POST to the action endpoint\n    const response = await fetch(`/_zero/actions/${id}`, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify(data ?? null),\n    })\n    if (!response.ok) {\n      const body = await response.json().catch(() => ({}))\n      throw new Error((body as { error?: string }).error ?? `Action failed: ${response.statusText}`)\n    }\n    return response.json()\n  }\n\n  callable.actionId = id\n  return callable as Action<T>\n}\n\n/** Get all registered actions. Useful for testing. */\nexport function getRegisteredActions(): Map<string, RegisteredAction> {\n  return actionRegistry\n}\n\n/**\n * Reset the action registry. Useful for testing.\n * @internal\n */\nexport function _resetActions(): void {\n  actionRegistry.clear()\n}\n\n// ─── Server handler ──────────────────────────────────────────────────────────\n\n/**\n * Create a middleware that handles action requests at `/_zero/actions/*`.\n * Mount this before the SSR handler in the server entry.\n */\nexport function createActionMiddleware(): (\n  ctx: MiddlewareContext,\n) => Response | undefined | Promise<Response | undefined> {\n  return async (ctx: MiddlewareContext) => {\n    if (!ctx.path.startsWith('/_zero/actions/')) return\n\n    const actionId = ctx.path.slice('/_zero/actions/'.length)\n    const action = actionRegistry.get(actionId)\n\n    if (!action) {\n      return Response.json({ error: 'Action not found' }, { status: 404 })\n    }\n\n    if (ctx.req.method !== 'POST') {\n      return Response.json({ error: 'Method not allowed' }, { status: 405 })\n    }\n\n    return executeAction(action, ctx.req)\n  }\n}\n\nasync function executeAction(action: RegisteredAction, req: Request): Promise<Response> {\n  try {\n    const contentType = req.headers.get('content-type') ?? ''\n    let formData: FormData | null = null\n    let json: unknown = null\n\n    if (contentType.includes('application/json')) {\n      json = await req.json()\n    } else if (\n      contentType.includes('multipart/form-data') ||\n      contentType.includes('application/x-www-form-urlencoded')\n    ) {\n      formData = await req.formData()\n    }\n\n    const result = await action.handler({\n      request: req,\n      formData,\n      json,\n      headers: req.headers,\n    })\n\n    return Response.json(result ?? null)\n  } catch (err) {\n    const message = err instanceof Error ? err.message : 'Internal server error'\n    return Response.json({ error: message }, { status: 500 })\n  }\n}\n"],"mappings":";AAmCA,MAAM,iCAAiB,IAAI,KAA+B;;;;;;;;;;;;;;;;;AAkB1D,SAAgB,aAA0B,SAAsC;CAC9E,MAAM,KAAK,UAAU,OAAO,YAAY,CAAC,MAAM,GAAG,EAAE;AAEpD,gBAAe,IAAI,IAAI;EAAE;EAAa;EAA0B,CAAC;CAEjE,MAAM,WAAW,OAAO,SAA+B;AAErD,MAAI,OAAO,WAAW,WAAW,YAC/B,QAAO,QAAQ;GACb,SAAS,IAAI,QAAQ,kCAAkC,MAAM;IAC3D,QAAQ;IACR,SAAS,EAAE,gBAAgB,oBAAoB;IAC/C,MAAM,KAAK,UAAU,QAAQ,KAAK;IACnC,CAAC;GACF,UAAU;GACV,MAAM,QAAQ;GACd,SAAS,IAAI,QAAQ,EAAE,gBAAgB,oBAAoB,CAAC;GAC7D,CAAC;EAIJ,MAAM,WAAW,MAAM,MAAM,kBAAkB,MAAM;GACnD,QAAQ;GACR,SAAS,EAAE,gBAAgB,oBAAoB;GAC/C,MAAM,KAAK,UAAU,QAAQ,KAAK;GACnC,CAAC;AACF,MAAI,CAAC,SAAS,IAAI;GAChB,MAAM,OAAO,MAAM,SAAS,MAAM,CAAC,aAAa,EAAE,EAAE;AACpD,SAAM,IAAI,MAAO,KAA4B,SAAS,kBAAkB,SAAS,aAAa;;AAEhG,SAAO,SAAS,MAAM;;AAGxB,UAAS,WAAW;AACpB,QAAO;;;AAIT,SAAgB,uBAAsD;AACpE,QAAO;;;;;;AAOT,SAAgB,gBAAsB;AACpC,gBAAe,OAAO;;;;;;AASxB,SAAgB,yBAE0C;AACxD,QAAO,OAAO,QAA2B;AACvC,MAAI,CAAC,IAAI,KAAK,WAAW,kBAAkB,CAAE;EAE7C,MAAM,WAAW,IAAI,KAAK,MAAM,GAAyB;EACzD,MAAM,SAAS,eAAe,IAAI,SAAS;AAE3C,MAAI,CAAC,OACH,QAAO,SAAS,KAAK,EAAE,OAAO,oBAAoB,EAAE,EAAE,QAAQ,KAAK,CAAC;AAGtE,MAAI,IAAI,IAAI,WAAW,OACrB,QAAO,SAAS,KAAK,EAAE,OAAO,sBAAsB,EAAE,EAAE,QAAQ,KAAK,CAAC;AAGxE,SAAO,cAAc,QAAQ,IAAI,IAAI;;;AAIzC,eAAe,cAAc,QAA0B,KAAiC;AACtF,KAAI;EACF,MAAM,cAAc,IAAI,QAAQ,IAAI,eAAe,IAAI;EACvD,IAAI,WAA4B;EAChC,IAAI,OAAgB;AAEpB,MAAI,YAAY,SAAS,mBAAmB,CAC1C,QAAO,MAAM,IAAI,MAAM;WAEvB,YAAY,SAAS,sBAAsB,IAC3C,YAAY,SAAS,oCAAoC,CAEzD,YAAW,MAAM,IAAI,UAAU;EAGjC,MAAM,SAAS,MAAM,OAAO,QAAQ;GAClC,SAAS;GACT;GACA;GACA,SAAS,IAAI;GACd,CAAC;AAEF,SAAO,SAAS,KAAK,UAAU,KAAK;UAC7B,KAAK;EACZ,MAAM,UAAU,eAAe,QAAQ,IAAI,UAAU;AACrD,SAAO,SAAS,KAAK,EAAE,OAAO,SAAS,EAAE,EAAE,QAAQ,KAAK,CAAC"}