@plitzi/sdk-server 0.32.4 → 0.32.6

package/dist/src/modules/mcp/types/aiSchema.d.ts

@@ -0,0 +1,218 @@
+import { Environment } from '@plitzi/sdk-shared';
+export type Env = Environment;
+/** CSS declarations for one selector state. Keys are kebab-case CSS properties (see plitzi://css-properties). */
+export type CssProps = Record<string, string | number>;
+export interface DisplayModeCss {
+    desktop?: CssProps;
+    tablet?: CssProps;
+    mobile?: CssProps;
+}
+export interface ResourceEnvelope<T> {
+    stateVersion: string;
+    data: T;
+}
+/**
+ * Read projections follow a filesystem model: list cheap summaries/skeletons, then read one element's detail
+ * on demand. Heavy per-element data (props, style) lives only in AIElementDetail, never in the listings.
+ */
+export interface AIPageSummary {
+    ref: string;
+    label: string;
+    slug: string;
+    default: boolean;
+    /** Whether the page is served by the published SDK runtime. A disabled page (`false`) is not routable/accessible
+     *  to end users, but stays fully editable here. Defaults to true. */
+    enabled: boolean;
+    /** The ref of the folder this page lives in (a PageFolder id), or undefined for a root-level page. */
+    folder?: string;
+    elementCount: number;
+}
+/** A page folder in the sidebar tree. `ref` is the folder's id (there is no separate idRef); pages reference it
+ *  by that id via their `folder`, and nested folders via `parentId`. */
+export interface AIFolder {
+    ref: string;
+    name: string;
+    slug: string;
+    parentId?: string;
+}
+export interface AISkeletonNode {
+    ref: string;
+    type: string;
+    label: string;
+    subType?: string;
+    /** This element's version — identical to the stateVersion a direct element read or search hit returns for it. Diff
+     *  it against a version you already hold to re-read (plitzi_read) only the nodes that actually changed. */
+    stateVersion?: string;
+    /** The class refs this node attaches on its base selector — names only, no CSS. Lets an agent map element →
+     *  class straight from the page skeleton, without a per-element read just to learn which class it uses. */
+    base?: string[];
+    /** Class refs attached on non-base slots (slot → class refs), names only. */
+    slots?: Record<string, string[]>;
+    childCount: number;
+    children?: AISkeletonNode[];
+}
+export interface AIPageSkeleton {
+    ref: string;
+    label: string;
+    slug: string;
+    default: boolean;
+    /** Whether the page is served by the published SDK runtime. A disabled page (`false`) is not routable/accessible
+     *  to end users, but stays fully editable here. Defaults to true. */
+    enabled: boolean;
+    /** Route params bound by the slug (e.g. ":spaceId" → ["spaceId"]). Valid as {{name}} references on this page,
+     *  alongside the space-level plitzi://schema-variables. */
+    routeParams: string[];
+    tree: AISkeletonNode[];
+}
+/** Every style a page uses in one payload: the class definitions its elements attach (deduplicated, with CSS)
+ *  and the global element selectors that affect any element type present on the page. Collapses "what styles
+ *  does this page use" to a single read, with no reliance on a shared class-naming prefix. */
+export interface AIPageStyles {
+    ref: string;
+    definitions: AIDefinition[];
+    globalStyles: AIGlobalStyle[];
+}
+/** Which variant each attached class/selector currently uses on this element (element.definition.initialState
+ *  .styleVariant). Outer key = class ref, inner key = selector (`base` or a slot), value = variant name(s). */
+export type AIStyleVariantSelection = Record<string, Record<string, string | string[]>>;
+/** The element's initial (default) state overrides. `styleVariant` picks which variant of its classes is active;
+ *  `visibility` hides/shows it initially. Kept minimal — the two fields agents actually set. */
+export interface AIInitialState {
+    styleVariant?: AIStyleVariantSelection;
+    visibility?: boolean;
+}
+/** One data binding: connect a data `source` to the element field named by `to` (a prop, a style value, or an
+ *  initial-state key, per its category). `transformers` reshape the value; `when` gates the binding. */
+export interface AIBinding {
+    id: string;
+    to: string;
+    source: string;
+    transformers?: Array<{
+        action: string;
+        params: Record<string, string>;
+        enabled?: boolean;
+    }>;
+    when?: unknown;
+    enabled?: boolean;
+}
+/** Data bindings on an element, grouped by what they feed: element props (`attributes`), style values (`style`),
+ *  or initial-state keys (`initialState`). */
+export type AIBindings = Partial<Record<'attributes' | 'style' | 'initialState', AIBinding[]>>;
+export type AIInteractionNodeType = 'trigger' | 'globalCallback' | 'callback' | 'utility';
+/** One step of an interaction flow, projected from the stored doubly-linked node. Order is conveyed by the
+ *  position in `AIInteractionFlow.nodes`; the stored beforeNode/afterNode/flowId links are computed on write. */
+export interface AIInteractionNode {
+    id: string;
+    title: string;
+    nodeType: AIInteractionNodeType;
+    action: string;
+    params?: Record<string, unknown>;
+    enabled?: boolean;
+    when?: unknown;
+    /** Source element the callback targets (globalCallback/utility). Defaults to this element on write. */
+    elementId?: string;
+    preview?: Record<string, unknown>;
+}
+/** One interaction flow on an element: a trigger (first node) followed by the callbacks/utilities it runs, in
+ *  order. `flowId` equals the trigger node id. */
+export interface AIInteractionFlow {
+    flowId: string;
+    nodes: AIInteractionNode[];
+}
+export interface AIElementDetail {
+    ref: string;
+    type: string;
+    subType?: string;
+    label: string;
+    pageRef: string;
+    parentRef?: string;
+    props?: Record<string, unknown>;
+    style: {
+        base: string[];
+        slots: Record<string, string[]>;
+    };
+    /** CSS of the definitions referenced by `style` (keyed by class ref), inlined so an edit needs no follow-up
+     *  read of each definition. Present only for refs that resolve to a definition. */
+    resolvedStyle?: Record<string, AIDefinition>;
+    /** Global (type 'element') styles that also affect this element because they target its type — every element of
+     *  the type inherits them. Read-only here (not editable as definitions); shown so the effective CSS is complete. */
+    globalStyles?: AIGlobalStyle[];
+    /** Id rule (type 'id') targeting this element by its DOM `id` attribute (`#id`). Present only when the element
+     *  carries an `id` that a rule matches. Edit it with the id-style tools (never as a definition). */
+    idStyle?: AIIdStyle;
+    /** Variant names each attached class exposes (deduped across its selectors), so the agent knows a class HAS a
+     *  variant (e.g. a button class with "primary") before applying it via `initialState.styleVariant`. */
+    availableVariants?: Record<string, string[]>;
+    /** Which variant/visibility this element applies today (element.definition.initialState). */
+    initialState?: AIInitialState;
+    /** Data bindings on this element, grouped by category. */
+    bindings?: AIBindings;
+    /** Interaction flows on this element (event → ordered callbacks). */
+    interactions?: AIInteractionFlow[];
+    childRefs?: string[];
+}
+/** A global element style (a type 'element' StyleItem): its CSS applies to every element whose type equals
+ *  `appliesToType`. It is not an addressable class definition — editing it would change every such element. */
+export interface AIGlobalStyle extends AIDefinition {
+    appliesToType: string;
+}
+/** An id rule (a type 'id' StyleItem): its CSS targets the single element whose DOM `id` equals `targetId`
+ *  (the CSS equivalent of `#id { … }`). Style one element by giving it an `id` attribute and writing this rule;
+ *  prefer a class definition when the styling could be reused. */
+export interface AIIdStyle extends AIDefinition {
+    targetId: string;
+}
+export interface AIDefinitionSlot extends DisplayModeCss {
+    states?: Record<string, DisplayModeCss>;
+    variants?: Record<string, DisplayModeCss>;
+}
+export interface AIDefinition extends AIDefinitionSlot {
+    ref: string;
+    slots?: Record<string, AIDefinitionSlot>;
+}
+export type StyleVariableCategory = 'color' | 'spacing' | 'shadow' | 'custom';
+export type StyleVariableValue = string | number | {
+    light?: string;
+    dark?: string;
+    default?: string;
+};
+export interface AIStyleVariable {
+    name: string;
+    reference: string;
+    value: StyleVariableValue;
+}
+export interface AISchemaVariable {
+    name: string;
+    reference: string;
+    category: string;
+    type: string;
+    value: string | number | boolean;
+    subValues?: Array<{
+        when: unknown;
+        value: string | number | boolean;
+    }>;
+}
+/** Space-level settings: the arbitrary global CSS (`customCss`), state persistence, and the user/auth provider
+ *  configuration. Every field is optional — a patch changes only the keys it sends. */
+export interface AISettings {
+    customCss?: string;
+    keepState?: boolean;
+    stateStorage?: 'localStorage' | 'sessionStorage';
+    userProvider?: 'auth0' | 'basic' | 'custom' | '';
+    auth0Domain?: string;
+    auth0ClientId?: string;
+    tokenStorage?: 'localStorage' | 'sessionStorage' | '';
+    loginUrl?: string;
+    userUrl?: string;
+    refreshUrl?: string;
+    logoutUrl?: string;
+    detailsPath?: string;
+    tokenPath?: string;
+    expirationTimePath?: string;
+}
+export interface ValidationError {
+    path: string;
+    message: string;
+    hint: string;
+    validValues?: unknown[];
+}

package/dist/src/modules/mcp/types/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './aiSchema';
+export type * from './toolTypes';
+export type * from './previewTypes';
+export type * from './screenshotTypes';

package/dist/src/modules/mcp/types/previewTypes.d.ts

@@ -0,0 +1,25 @@
+import { ValidationError } from './aiSchema';
+import { Operation } from '../tools/operations';
+export type PreviewRequestBody = {
+    spaceId: number;
+    env?: string;
+    pageRef?: string;
+    operations?: Operation[];
+};
+export type PreviewResult = {
+    ok: true;
+    token?: string;
+    pagePath: string;
+    html: string;
+    stateVersion: string;
+} | {
+    ok: false;
+    error: string;
+    message: string;
+    errors?: ValidationError[];
+};
+/** How the MCP tools reach the renderer. The consumer injects an implementation (an HTTP client to the SSR
+ *  `/preview` endpoint, or an in-process call when co-located); absent means preview is not wired. */
+export type PreviewClient = {
+    render: (body: PreviewRequestBody) => Promise<PreviewResult>;
+};

package/dist/src/modules/mcp/types/screenshotTypes.d.ts

@@ -0,0 +1,29 @@
+export type Viewport = {
+    label: string;
+    width: number;
+    height: number;
+};
+export type ScreenshotImage = {
+    label: string;
+    mimeType: string;
+    data: string;
+};
+export type ScreenshotResult = {
+    ok: true;
+    images: ScreenshotImage[];
+} | {
+    ok: false;
+    error: string;
+    message: string;
+};
+export type ScreenshotInput = {
+    pagePath: string;
+    token?: string;
+    viewports: Viewport[];
+};
+/** How plitzi_screenshot reaches the headless-browser service. The consumer injects an implementation (an HTTP
+ *  client to the dedicated browser pod); absent → the tool is not registered. A capture that fails (pod down)
+ *  returns `ok:false` rather than throwing, so the tool can degrade to the HTML preview. */
+export type ScreenshotClient = {
+    capture: (input: ScreenshotInput) => Promise<ScreenshotResult>;
+};

package/dist/src/modules/mcp/types/toolTypes.d.ts

@@ -0,0 +1,138 @@
+import { AIDefinition, AIElementDetail, ValidationError } from './aiSchema';
+import { Operation } from '../tools/operations';
+import { Schema, Style } from '@plitzi/sdk-shared';
+/** The element schema and the style schema persist independently (Space model / Style model), so each has
+ *  its own optional persister. When one is absent, that schema is applied in memory but reported unsaved. */
+export interface Persisters {
+    schema?: (schema: Schema) => Promise<void>;
+    style?: (style: Style) => Promise<void>;
+}
+export interface Conflict {
+    resourceUri: string;
+    expectedVersion: string;
+    currentVersion: string;
+}
+export interface ChangedResource {
+    uri: string;
+    stateVersion: string;
+}
+/** Full detail of a created/updated element, plus its own uri and stateVersion so a follow-up edit of the same
+ *  element can guard with optimistic concurrency without an intermediate read. */
+export type WriteElement = AIElementDetail & {
+    uri: string;
+    stateVersion: string;
+};
+/** Write result: what changed and the new versions, plus the full detail of every element created/updated (with
+ *  its uri + stateVersion) so the caller has that context without a follow-up read. Other resources (pages,
+ *  definitions, variables) still report only uri+version — re-read them if needed. */
+export interface WriteResponse {
+    applied: boolean;
+    dryRun?: boolean;
+    persisted?: boolean;
+    summary: {
+        created: number;
+        updated: number;
+        deleted: number;
+    };
+    changed: ChangedResource[];
+    elements?: WriteElement[];
+    warnings?: string[];
+    errors?: ValidationError[];
+    conflict?: {
+        message: string;
+        conflicts: Conflict[];
+    };
+}
+/** The outcome of applying a batch to the space in memory: counts, which schema(s) changed (so the caller can
+ *  persist each independently), the invalidated resource URIs and the refs of the elements it created/updated. */
+export interface MutationOutcome {
+    created: number;
+    updated: number;
+    deleted: number;
+    staleResources: string[];
+    elementRefs: string[];
+    errors: ValidationError[];
+    changedSchema: boolean;
+    changedStyle: boolean;
+}
+export interface ApplyInput {
+    environment?: string;
+    dryRun?: boolean;
+    expectedResourceVersions?: Record<string, string>;
+    operations: Operation[];
+}
+export interface ValidateInput {
+    environment?: string;
+    operations: Operation[];
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: string[];
+}
+export interface SearchInput {
+    query: string;
+    filters?: {
+        type?: string;
+        pageRef?: string;
+    };
+    /** 'detail' inlines each hit's full props/style so an edit needs no follow-up read. */
+    include?: 'detail';
+    /** Max element hits to return in this page (default 50). */
+    limit?: number;
+    /** Element hits to skip before this page (default 0). */
+    offset?: number;
+}
+export interface SearchHit {
+    pageRef: string;
+    ref: string;
+    uri: string;
+    pageUri: string;
+    stateVersion: string;
+    parentRef?: string;
+    /** Ancestor labels from the page down to and including this element. */
+    path: string[];
+    label: string;
+    type: string;
+    matches: string[];
+    detail?: AIElementDetail;
+}
+export interface SearchPageHit {
+    ref: string;
+    uri: string;
+    stateVersion: string;
+    label: string;
+    slug: string;
+    matches: string[];
+}
+export interface SearchResponse {
+    results: SearchHit[];
+    /** Total element hits matching the query across all pages, before offset/limit. */
+    total: number;
+    /** Element hits skipped before this page (echoes the request's offset, defaulted). */
+    offset: number;
+    /** Page size applied to element hits (echoes the request's limit, defaulted). */
+    limit: number;
+    /** The offset to pass next to fetch the following page. Present only while more hits remain past this page. */
+    nextOffset?: number;
+    /** Style definitions whose ref matches the query, with their full CSS — so finding a class by name closes the
+     *  loop to its style without a separate read. Present only when at least one definition matches. */
+    definitions?: AIDefinition[];
+    /** Pages whose name or slug matches the query (element hits never include pages). Each carries the page uri +
+     *  stateVersion, ready to open or edit. Present only when at least one page matches. */
+    pages?: SearchPageHit[];
+}
+export interface ReadInput {
+    uris: string[];
+}
+export interface ReadHit {
+    uri: string;
+    stateVersion?: string;
+    data?: unknown;
+    error?: string;
+    message?: string;
+    hint?: string;
+}
+export interface ReadResponse {
+    results: ReadHit[];
+}

package/dist/src/modules/ssr/buildBody.d.ts

@@ -1,9 +1,9 @@
 import { TtlCache } from '../../helpers/cache';
 import { RequestMetrics } from '../../helpers/metrics';
 import { PluginManager } from '../../plugins/manager';
-import { Environment, SSRRenderResult, SSRRequest, SSRServerConfig, SSRTemplateFn } from '@plitzi/sdk-shared';
+import { Environment, OfflineDataRaw, SSRRenderResult, SSRRequest, SSRServerConfig, SSRTemplateFn } from '@plitzi/sdk-shared';
 export type BuildBodyResult = {
     body?: string;
     result: SSRRenderResult;
 };
-export declare const buildBody: (req: SSRRequest, config: SSRServerConfig, spaceId: number, environment: Environment, revision: number, renderFn: SSRTemplateFn, pluginManager: PluginManager, offlineDataCache?: TtlCache<string>, metrics?: RequestMetrics) => Promise<BuildBodyResult>;
+export declare const buildBody: (req: SSRRequest, config: SSRServerConfig, spaceId: number, environment: Environment, revision: number, renderFn: SSRTemplateFn, pluginManager: PluginManager, offlineDataCache?: TtlCache<string>, metrics?: RequestMetrics, offlineDataOverride?: OfflineDataRaw) => Promise<BuildBodyResult>;

package/dist/src/modules/ssr/prepareRender.d.ts

@@ -2,7 +2,7 @@ import { ComponentProps } from './Component';
 import { TtlCache } from '../../helpers/cache';
 import { RequestMetrics } from '../../helpers/metrics';
 import { PluginManager } from '../../plugins/manager';
-import { Environment, PluginEntry, SSRRequest, SSRServerConfig, SSRTemplateProps } from '@plitzi/sdk-shared';
+import { Environment, OfflineDataRaw, PluginEntry, SSRRequest, SSRServerConfig, SSRTemplateProps } from '@plitzi/sdk-shared';
 export type RenderPrep = {
     componentProps: ComponentProps;
     entries: PluginEntry[];
@@ -10,4 +10,4 @@ export type RenderPrep = {
         offlineData: string;
     };
 };
-export declare const prepareRender: (req: SSRRequest, config: SSRServerConfig, spaceId: number, environment: Environment, revision: number, pluginManager: PluginManager, offlineDataCache?: TtlCache<string>, metrics?: RequestMetrics) => Promise<RenderPrep>;
+export declare const prepareRender: (req: SSRRequest, config: SSRServerConfig, spaceId: number, environment: Environment, revision: number, pluginManager: PluginManager, offlineDataCache?: TtlCache<string>, metrics?: RequestMetrics, offlineDataOverride?: OfflineDataRaw) => Promise<RenderPrep>;

package/dist/src/modules/ssr/preview.d.ts

@@ -0,0 +1,16 @@
+import { PREVIEW_TOKEN_PARAM } from '../mcp/constants';
+import { ServerCaches } from '../../helpers/cache';
+import { PluginManager } from '../../plugins/manager';
+import { PreviewRequestBody, PreviewResult } from '../mcp/types';
+import { DraftStore, OfflineDataRaw, SSRRequest, SSRServerConfig, SSRTemplateFn } from '@plitzi/sdk-shared';
+export { PREVIEW_TOKEN_PARAM };
+/** In-memory one-shot draft store — the default when the consumer injects none. Fine for a single replica;
+ *  a multi-replica deployment must inject a shared store so a preview URL resolves on any replica. */
+export declare const createMemoryDraftStore: () => DraftStore;
+/** Consume the draft override for a render, if the request carries a valid preview token. Returns undefined on
+ *  a normal request (renders persisted state) or when the token is unknown/expired (one-shot / TTL). */
+export declare const takeDraftOverride: (req: SSRRequest, config: SSRServerConfig) => Promise<OfflineDataRaw | undefined>;
+/** Build a preview of a page: apply any unsaved `operations` to a clone (never persisted), render the resulting
+ *  draft to full HTML via the SSR pipeline, and stash the draft under a one-shot token so a browser can fetch
+ *  the exact same render at `?__pt=<token>` (for screenshots). With no operations it previews persisted state. */
+export declare const createPreview: (body: PreviewRequestBody, config: SSRServerConfig, renderFn: SSRTemplateFn, pluginManager: PluginManager, caches: ServerCaches) => Promise<PreviewResult>;

package/dist/src/modules/ssr/streamBody.d.ts

@@ -1,5 +1,5 @@
 import { TtlCache } from '../../helpers/cache';
 import { RequestMetrics } from '../../helpers/metrics';
 import { PluginManager } from '../../plugins/manager';
-import { Environment, SSRRequest, SSRResponseHelpers, SSRServerConfig, SSRTemplateFn } from '@plitzi/sdk-shared';
-export declare const streamBody: (req: SSRRequest, res: SSRResponseHelpers, config: SSRServerConfig, spaceId: number, environment: Environment, revision: number, renderFn: SSRTemplateFn, pluginManager: PluginManager, offlineDataCache?: TtlCache<string>, htmlCache?: TtlCache<string>, cacheKey?: string, metrics?: RequestMetrics) => Promise<void>;
+import { Environment, OfflineDataRaw, SSRRequest, SSRResponseHelpers, SSRServerConfig, SSRTemplateFn } from '@plitzi/sdk-shared';
+export declare const streamBody: (req: SSRRequest, res: SSRResponseHelpers, config: SSRServerConfig, spaceId: number, environment: Environment, revision: number, renderFn: SSRTemplateFn, pluginManager: PluginManager, offlineDataCache?: TtlCache<string>, htmlCache?: TtlCache<string>, cacheKey?: string, metrics?: RequestMetrics, offlineDataOverride?: OfflineDataRaw) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-server",
-  "version": "0.32.4",
+  "version": "0.32.6",
   "license": "AGPL-3.0",
   "files": [
     "dist"
@@ -23,8 +23,9 @@
   "sideEffects": false,
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@plitzi/plitzi-sdk": "0.32.4",
-    "@plitzi/sdk-shared": "0.32.4",
+    "@plitzi/plitzi-sdk": "0.32.6",
+    "@plitzi/sdk-schema": "0.32.6",
+    "@plitzi/sdk-shared": "0.32.6",
     "ejs": "^6.0.1",
     "esbuild": "^0.28.1",
     "zod": "^4.4.3"
@@ -35,19 +36,19 @@
   },
   "devDependencies": {
     "@types/ejs": "^3.1.5",
-    "@types/node": "^26.0.0",
+    "@types/node": "^26.1.1",
     "@types/react": "^19.2.17",
-    "@vitejs/plugin-react": "^6.0.2",
-    "@vitest/coverage-v8": "^4.1.9",
-    "eslint": "^9.39.4",
+    "@vitejs/plugin-react": "^6.0.4",
+    "@vitest/coverage-v8": "^4.1.10",
+    "eslint": "^9.39.5",
     "eslint-plugin-import": "^2.32.0",
-    "react": "^19.2.7",
-    "react-dom": "^19.2.7",
-    "tsx": "^4.22.4",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "tsx": "^4.23.1",
     "typescript": "^6.0.3",
-    "vite": "^8.0.16",
-    "vite-plugin-dts": "^5.0.2",
-    "vitest": "^4.1.9"
+    "vite": "^8.1.5",
+    "vite-plugin-dts": "^5.0.3",
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "start:dev": "node --import ./src/standalone/register-alias.mjs --watch src/standalone/server.ts",
@@ -59,6 +60,7 @@
     "lint": "TIMING=1 eslint ./src",
     "typecheck": "tsc -p tsconfig.app.json --noEmit",
     "test": "vitest run",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "bench": "vitest bench --run"
   }
 }

package/dist/_virtual/_rolldown/runtime.js

@@ -1,13 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-export { __exportAll };

package/dist/core/requestHandler.js

@@ -1,126 +0,0 @@
-import { parseRequest, readRawBody } from "./requestParser.js";
-import { serveStatic } from "./staticFiles.js";
-import { buildResponseHelpers } from "../helpers/buildResponseHelpers.js";
-import { runMiddlewares } from "../helpers/runMiddlewares.js";
-import { authMiddleware } from "../middlewares/auth.js";
-import { basicAuthMiddleware } from "../middlewares/basicAuth.js";
-import { spaceDeploymentMiddleware } from "../middlewares/spaceDeployment.js";
-import { handleMcp } from "../modules/mcp/handler.js";
-import { handleRsc } from "../modules/rsc/handler.js";
-import { renderSSR } from "../modules/ssr/handler.js";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-//#region src/core/requestHandler.ts
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
-var BUILTIN_PUBLIC_DIR = path.resolve(__dirname, "../public");
-var safeRedirectTarget = (req) => {
-	const redirectParam = req.query["redirect"];
-	return redirectParam && redirectParam.startsWith("/") && !redirectParam.startsWith("//") ? redirectParam : "/";
-};
-var handleRequest = async (raw, rawRes, config, port, renderFn, caches, pluginManager) => {
-	const req = parseRequest(raw);
-	const res = buildResponseHelpers(rawRes, req.headers["accept-encoding"]);
-	if (req.path === "\0") {
-		res.setStatus(400);
-		res.end();
-		return;
-	}
-	res.setHeader("X-Content-Type-Options", "nosniff");
-	res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
-	res.setHeader("X-DNS-Prefetch-Control", "off");
-	const frameOptions = config.frameOptions === void 0 ? "DENY" : config.frameOptions;
-	if (frameOptions) if (Array.isArray(frameOptions)) res.setHeader("Content-Security-Policy", `frame-ancestors ${frameOptions.join(" ")}`);
-	else {
-		res.setHeader("X-Frame-Options", frameOptions);
-		res.setHeader("Content-Security-Policy", `frame-ancestors '${frameOptions === "DENY" ? "none" : "self"}'`);
-	}
-	if ((config.httpVersion ?? 2) >= 3) res.setHeader("Alt-Svc", `h3=":${port}"; ma=86400`);
-	if (serveStatic(req, res, BUILTIN_PUBLIC_DIR)) return;
-	if (config.publicDir && serveStatic(req, res, config.publicDir)) return;
-	if (req.path.startsWith("/.well-known/")) {
-		res.setStatus(404);
-		res.end();
-		return;
-	}
-	if (req.path.startsWith(pluginManager.urlPrefix + "/")) {
-		const relative = req.path.slice(pluginManager.urlPrefix.length);
-		const pluginName = relative.split("/")[1];
-		if (pluginName && pluginManager.hasPlugin(pluginName)) {
-			await pluginManager.prepare(pluginName);
-			if (serveStatic({
-				...req,
-				path: relative
-			}, res, pluginManager.outputDir)) return;
-		}
-		res.setStatus(404);
-		res.send("Not found");
-		return;
-	}
-	const loginPath = config.loginPath === false ? null : config.loginPath ?? "/auth/login";
-	if (loginPath && req.method === "POST" && req.path === loginPath) {
-		req.body = await readRawBody(raw);
-		const isLoggedIn = await config.adapters.onLogin?.(req, res);
-		if (req.headers["sec-fetch-mode"] === "navigate") {
-			res.setStatus(303);
-			res.setHeader("Location", isLoggedIn ? safeRedirectTarget(req) : loginPath);
-			res.end();
-			return;
-		}
-		res.setStatus(isLoggedIn ? 200 : 401);
-		res.end();
-		return;
-	}
-	const logoutPath = config.logoutPath === false ? null : config.logoutPath ?? "/auth/logout";
-	if (logoutPath && req.method === "POST" && req.path === logoutPath) {
-		req.body = await readRawBody(raw);
-		await config.adapters.onLogout?.(req, res);
-		if (req.headers["sec-fetch-mode"] === "navigate") {
-			res.setStatus(303);
-			res.setHeader("Location", safeRedirectTarget(req));
-			res.end();
-			return;
-		}
-		res.setStatus(204);
-		res.end();
-		return;
-	}
-	if (config.static) for (const [prefix, rootDir] of Object.entries(config.static)) {
-		const normalizedPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
-		if (req.path === prefix || req.path.startsWith(normalizedPrefix)) {
-			if (serveStatic({
-				...req,
-				path: req.path.slice(prefix.length) || "/"
-			}, res, rootDir)) return;
-		}
-	}
-	const mcpPath = config.mcp?.path ?? "/mcp";
-	if (config.mcp && (config.mcp.enabled ?? true) && req.path.startsWith(mcpPath)) {
-		await handleMcp(raw, rawRes, config.mcp);
-		return;
-	}
-	if (await runMiddlewares([
-		spaceDeploymentMiddleware(config.adapters),
-		basicAuthMiddleware({ cacheTtlMs: config.cacheTtlMs }),
-		authMiddleware(config.adapters),
-		...config.middlewares || []
-	], req, res) || res.status !== 200) return;
-	const rscPath = config.rsc?.path ?? "/_rsc";
-	if ((config.rsc?.enabled ?? !!config.adapters.getRscData) && req.method === "GET" && req.path === rscPath) {
-		await handleRsc(req, res, config, pluginManager, caches.rsc);
-		return;
-	}
-	await renderSSR(req, res, config, renderFn, pluginManager, caches);
-};
-var makeHandler = (config, port, renderFn, caches, pluginManager) => {
-	return (raw, rawRes) => {
-		handleRequest(raw, rawRes, config, port, renderFn, caches, pluginManager).catch((err) => {
-			console.error("[SSR] Unhandled error:", err);
-			try {
-				if (!rawRes.headersSent) rawRes.writeHead(500, { "Content-Type": "text/plain" });
-				rawRes.end("Internal Server Error");
-			} catch {}
-		});
-	};
-};
-//#endregion
-export { makeHandler };