alepha 0.13.1 → 0.13.2

package/dist/server-swagger/index.js

@@ -1,722 +1,19 @@
-import { $atom, $hook, $inject, $module, $use, Alepha, Descriptor, KIND, createDescriptor, isTypeFile, t } from "alepha";
-import { $permission, $realm, $role, AlephaSecurity, JwtProvider, SecurityProvider, userAccountInfoSchema } from "alepha/security";
-import { $action, ActionDescriptor, AlephaServer, ForbiddenError, HttpError, ServerProvider, ServerRouterProvider, UnauthorizedError } from "alepha/server";
-import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
-import { $logger } from "alepha/logger";
-import { $cache, AlephaCache } from "alepha/cache";
-import { DateTimeProvider } from "alepha/datetime";
-import { createReadStream } from "node:fs";
-import { access, readdir, stat } from "node:fs/promises";
-import { basename, isAbsolute, join } from "node:path";
-import { FileDetector, FileSystemProvider } from "alepha/file";
+import "alepha/server/security";
+import { $atom, $hook, $inject, $module, $use, Alepha, KIND, Primitive, createPrimitive, isTypeFile, t } from "alepha";
+import { $action, AlephaServer, ServerProvider, ServerRouterProvider } from "alepha/server";
+import { AlephaServerCache } from "alepha/server/cache";
+import { AlephaServerStatic, ServerStaticProvider } from "alepha/server/static";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { FileSystemProvider } from "alepha/file";
+import { $logger } from "alepha/logger";
+import { AlephaSecurity } from "alepha/security";
 
-//#region src/server-security/providers/ServerBasicAuthProvider.ts
-var ServerBasicAuthProvider = class {
-	alepha = $inject(Alepha);
-	log = $logger();
-	routerProvider = $inject(ServerRouterProvider);
-	realm = "Secure Area";
-	/**
-	* Registered basic auth descriptors with their configurations
-	*/
-	registeredAuths = [];
-	/**
-	* Register a basic auth configuration (called by descriptors)
-	*/
-	registerAuth(config) {
-		this.registeredAuths.push(config);
-	}
-	onStart = $hook({
-		on: "start",
-		handler: async () => {
-			for (const auth of this.registeredAuths) if (auth.paths) for (const pattern of auth.paths) {
-				const matchedRoutes = this.routerProvider.getRoutes(pattern);
-				for (const route of matchedRoutes) route.secure = { basic: {
-					username: auth.username,
-					password: auth.password
-				} };
-			}
-			if (this.registeredAuths.length > 0) this.log.info(`Initialized with ${this.registeredAuths.length} registered basic-auth configurations.`);
-		}
-	});
-	/**
-	* Hook into server:onRequest to check basic auth
-	*/
-	onRequest = $hook({
-		on: "server:onRequest",
-		handler: async ({ route, request }) => {
-			const routeAuth = route.secure;
-			if (typeof routeAuth === "object" && "basic" in routeAuth && routeAuth.basic) this.checkAuth(request, routeAuth.basic);
-		}
-	});
-	/**
-	* Hook into action:onRequest to check basic auth for actions
-	*/
-	onActionRequest = $hook({
-		on: "action:onRequest",
-		handler: async ({ action, request }) => {
-			const routeAuth = action.route.secure;
-			if (isBasicAuth(routeAuth)) this.checkAuth(request, routeAuth.basic);
-		}
-	});
-	/**
-	* Check basic authentication
-	*/
-	checkAuth(request, options) {
-		const authHeader = request.headers?.authorization;
-		if (!authHeader || !authHeader.startsWith("Basic ")) {
-			this.sendAuthRequired(request);
-			throw new HttpError({
-				status: 401,
-				message: "Authentication required"
-			});
-		}
-		const base64Credentials = authHeader.slice(6);
-		const credentials = Buffer.from(base64Credentials, "base64").toString("utf-8");
-		const colonIndex = credentials.indexOf(":");
-		const username = colonIndex !== -1 ? credentials.slice(0, colonIndex) : credentials;
-		const password = colonIndex !== -1 ? credentials.slice(colonIndex + 1) : "";
-		if (!this.timingSafeCredentialCheck(username, password, options.username, options.password)) {
-			this.sendAuthRequired(request);
-			this.log.warn(`Failed basic auth attempt for user`, { username });
-			throw new HttpError({
-				status: 401,
-				message: "Invalid credentials"
-			});
-		}
-	}
-	/**
-	* Performs a timing-safe comparison of credentials to prevent timing attacks.
-	* Always compares both username and password to avoid leaking which one is wrong.
-	*/
-	timingSafeCredentialCheck(inputUsername, inputPassword, expectedUsername, expectedPassword) {
-		const inputUserBuf = Buffer.from(inputUsername, "utf-8");
-		const expectedUserBuf = Buffer.from(expectedUsername, "utf-8");
-		const inputPassBuf = Buffer.from(inputPassword, "utf-8");
-		const expectedPassBuf = Buffer.from(expectedPassword, "utf-8");
-		return (this.safeCompare(inputUserBuf, expectedUserBuf) & this.safeCompare(inputPassBuf, expectedPassBuf)) === 1;
-	}
-	/**
-	* Compares two buffers in constant time, handling different lengths safely.
-	* Returns 1 if equal, 0 if not equal.
-	*/
-	safeCompare(input, expected) {
-		if (input.length !== expected.length) {
-			timingSafeEqual(input, input);
-			return 0;
-		}
-		return timingSafeEqual(input, expected) ? 1 : 0;
-	}
-	/**
-	* Send WWW-Authenticate header
-	*/
-	sendAuthRequired(request) {
-		request.reply.setHeader("WWW-Authenticate", `Basic realm="${this.realm}"`);
-	}
-};
-const isBasicAuth = (value) => {
-	return typeof value === "object" && !!value && "basic" in value && !!value.basic;
-};
-
-//#endregion
-//#region src/server-security/descriptors/$basicAuth.ts
-/**
-* Declares HTTP Basic Authentication for server routes.
-* This descriptor provides methods to protect routes with username/password authentication.
-*/
-const $basicAuth = (options) => {
-	return createDescriptor(BasicAuthDescriptor, options);
-};
-var BasicAuthDescriptor = class extends Descriptor {
-	serverBasicAuthProvider = $inject(ServerBasicAuthProvider);
-	get name() {
-		return this.options.name ?? `${this.config.propertyKey}`;
-	}
-	onInit() {
-		this.serverBasicAuthProvider.registerAuth(this.options);
-	}
-	/**
-	* Checks basic auth for the given request using this descriptor's configuration.
-	*/
-	check(request, options) {
-		const mergedOptions = {
-			...this.options,
-			...options
-		};
-		this.serverBasicAuthProvider.checkAuth(request, mergedOptions);
-	}
-};
-$basicAuth[KIND] = BasicAuthDescriptor;
-
-//#endregion
-//#region src/server-security/providers/ServerSecurityProvider.ts
-var ServerSecurityProvider = class {
-	log = $logger();
-	securityProvider = $inject(SecurityProvider);
-	jwtProvider = $inject(JwtProvider);
-	alepha = $inject(Alepha);
-	onConfigure = $hook({
-		on: "configure",
-		handler: async () => {
-			for (const action of this.alepha.descriptors($action)) {
-				if (action.options.disabled || action.options.secure === false || this.securityProvider.getRealms().length === 0) continue;
-				if (typeof action.options.secure !== "object") this.securityProvider.createPermission({
-					name: action.name,
-					group: action.group,
-					method: action.route.method,
-					path: action.route.path
-				});
-			}
-		}
-	});
-	onActionRequest = $hook({
-		on: "action:onRequest",
-		handler: async ({ action, request, options }) => {
-			if (action.options.secure === false && !options.user) {
-				this.log.trace("Skipping security check for route");
-				return;
-			}
-			if (isBasicAuth(action.route.secure)) return;
-			const permission = this.securityProvider.getPermissions().find((it) => it.path === action.route.path && it.method === action.route.method);
-			try {
-				request.user = this.createUserFromLocalFunctionContext(options, permission);
-				const route = action.route;
-				if (typeof route.secure === "object") this.check(request.user, route.secure);
-				this.alepha.state.set("alepha.server.request.user", this.alepha.codec.decode(userAccountInfoSchema, request.user));
-			} catch (error) {
-				if (action.options.secure || permission) throw error;
-				this.log.trace("Skipping security check for action");
-			}
-		}
-	});
-	onRequest = $hook({
-		on: "server:onRequest",
-		priority: "last",
-		handler: async ({ request, route }) => {
-			if (route.secure === false) {
-				this.log.trace("Skipping security check for route - explicitly disabled");
-				return;
-			}
-			if (isBasicAuth(route.secure)) return;
-			const permission = this.securityProvider.getPermissions().find((it) => it.path === route.path && it.method === route.method);
-			if (!request.headers.authorization && !route.secure && !permission) {
-				this.log.trace("Skipping security check for route - no authorization header and not secure");
-				return;
-			}
-			try {
-				request.user = await this.securityProvider.createUserFromToken(request.headers.authorization, { permission });
-				if (typeof route.secure === "object") this.check(request.user, route.secure);
-				this.alepha.state.set("alepha.server.request.user", this.alepha.codec.decode(userAccountInfoSchema, request.user));
-				this.log.trace("User set from request token", {
-					user: request.user,
-					permission
-				});
-			} catch (error) {
-				if (route.secure || permission) throw error;
-				this.log.trace("Skipping security check for route - error occurred", error);
-			}
-		}
-	});
-	check(user, secure) {
-		if (secure.realm) {
-			if (user.realm !== secure.realm) throw new ForbiddenError(`User must belong to realm '${secure.realm}' to access this route`);
-		}
-	}
-	/**
-	* Get the user account token for a local action call.
-	* There are three possible sources for the user:
-	* - `options.user`: the user passed in the options
-	* - `"system"`: the system user from the state (you MUST set state `server.security.system.user`)
-	* - `"context"`: the user from the request context (you MUST be in an HTTP request context)
-	*
-	* Priority order: `options.user` > `"system"` > `"context"`.
-	*
-	* In testing environment, if no user is provided, a test user is created based on the SecurityProvider's roles.
-	*/
-	createUserFromLocalFunctionContext(options, permission) {
-		const fromOptions = typeof options.user === "object" ? options.user : void 0;
-		const type = typeof options.user === "string" ? options.user : void 0;
-		let user;
-		const fromContext = this.alepha.context.get("request")?.user;
-		const fromSystem = this.alepha.state.get("alepha.server.security.system.user");
-		if (type === "system") user = fromSystem;
-		else if (type === "context") user = fromContext;
-		else user = fromOptions ?? fromContext ?? fromSystem;
-		if (!user) {
-			if (this.alepha.isTest() && !("user" in options)) return this.createTestUser();
-			throw new UnauthorizedError("User is required for calling this action");
-		}
-		const roles = user.roles ?? (this.alepha.isTest() ? this.securityProvider.getRoles().map((role) => role.name) : []);
-		let ownership;
-		if (permission) {
-			const result = this.securityProvider.checkPermission(permission, ...roles);
-			if (!result.isAuthorized) throw new ForbiddenError(`Permission '${this.securityProvider.permissionToString(permission)}' is required for this route`);
-			ownership = result.ownership;
-		}
-		return {
-			...user,
-			ownership
-		};
-	}
-	createTestUser() {
-		return {
-			id: randomUUID(),
-			name: "Test",
-			roles: this.securityProvider.getRoles().map((role) => role.name)
-		};
-	}
-	onClientRequest = $hook({
-		on: "client:onRequest",
-		handler: async ({ request, options }) => {
-			if (!this.alepha.isTest()) return;
-			if ("user" in options && options.user === void 0) return;
-			request.headers = new Headers(request.headers);
-			if (!request.headers.has("authorization")) {
-				const test = this.createTestUser();
-				const user = typeof options?.user === "object" ? options.user : void 0;
-				const sub = user?.id ?? test.id;
-				const roles = user?.roles ?? test.roles;
-				const token = await this.jwtProvider.create({
-					sub,
-					roles
-				}, user?.realm ?? this.securityProvider.getRealms()[0]?.name);
-				request.headers.set("authorization", `Bearer ${token}`);
-			}
-		}
-	});
-};
-
-//#endregion
-//#region src/server-security/index.ts
-/**
-* Plugin for Alepha Server that provides security features. Based on the Alepha Security module.
-*
-* By default, all $action will be guarded by a permission check.
-*
-* @see {@link ServerSecurityProvider}
-* @module alepha.server.security
-*/
-const AlephaServerSecurity = $module({
-	name: "alepha.server.security",
-	descriptors: [
-		$realm,
-		$role,
-		$permission,
-		$basicAuth
-	],
-	services: [
-		AlephaServer,
-		AlephaSecurity,
-		ServerSecurityProvider,
-		ServerBasicAuthProvider
-	]
-});
-
-//#endregion
-//#region src/server-cache/providers/ServerCacheProvider.ts
-ActionDescriptor.prototype.invalidate = async function() {
-	await this.alepha.inject(ServerCacheProvider).invalidate(this.route);
-};
-var ServerCacheProvider = class {
-	log = $logger();
-	alepha = $inject(Alepha);
-	time = $inject(DateTimeProvider);
-	cache = $cache({ provider: "memory" });
-	generateETag(content) {
-		return `"${createHash("md5").update(content).digest("hex")}"`;
-	}
-	async invalidate(route) {
-		if (!route.cache) return;
-		await this.cache.invalidate(this.createCacheKey(route));
-	}
-	onActionRequest = $hook({
-		on: "action:onRequest",
-		handler: async ({ action, request }) => {
-			const cache = action.route.cache;
-			if (this.shouldStore(cache)) {
-				const key = this.createCacheKey(action.route, request);
-				const cached = await this.cache.get(key);
-				if (cached) {
-					const body = cached.contentType === "application/json" ? JSON.parse(cached.body) : cached.body;
-					this.log.trace("Cache hit for action", {
-						key,
-						action: action.name
-					});
-					request.reply.body = body;
-				} else this.log.trace("Cache miss for action", {
-					key,
-					action: action.name
-				});
-			}
-		}
-	});
-	onActionResponse = $hook({
-		on: "action:onResponse",
-		handler: async ({ action, request, response }) => {
-			const cache = action.route.cache;
-			if (!this.shouldStore(cache) || !response) return;
-			if (request.reply.status && request.reply.status >= 400) return;
-			const contentType = typeof response === "string" ? "text/plain" : "application/json";
-			const body = contentType === "text/plain" ? response : JSON.stringify(response);
-			const generatedEtag = this.generateETag(body);
-			const lastModified = this.time.toISOString();
-			const key = this.createCacheKey(action.route, request);
-			this.log.trace("Storing response", {
-				key,
-				action: action.name
-			});
-			await this.cache.set(key, {
-				body,
-				lastModified,
-				contentType,
-				hash: generatedEtag
-			});
-			const cacheControl = this.buildCacheControlHeader(cache);
-			if (cacheControl) request.reply.setHeader("cache-control", cacheControl);
-		}
-	});
-	onRequest = $hook({
-		on: "server:onRequest",
-		handler: async ({ route, request }) => {
-			const cache = route.cache;
-			const shouldStore = this.shouldStore(cache);
-			const shouldUseEtag = this.shouldUseEtag(cache);
-			if (!shouldStore && !shouldUseEtag) return;
-			const key = this.createCacheKey(route, request);
-			const cached = await this.cache.get(key);
-			if (cached) {
-				if (request.headers["if-none-match"] === cached.hash || request.headers["if-modified-since"] === cached.lastModified) {
-					request.reply.status = 304;
-					request.reply.setHeader("etag", cached.hash);
-					request.reply.setHeader("last-modified", cached.lastModified);
-					this.log.trace("ETag match, returning 304", {
-						route: route.path,
-						etag: cached.hash
-					});
-					return;
-				}
-				if (shouldStore) {
-					this.log.trace("Cache hit for route", {
-						key,
-						route: route.path
-					});
-					request.reply.body = cached.body;
-					request.reply.status = cached.status ?? 200;
-					if (cached.contentType) request.reply.setHeader("Content-Type", cached.contentType);
-					request.reply.setHeader("etag", cached.hash);
-					request.reply.setHeader("last-modified", cached.lastModified);
-				}
-			} else if (shouldStore) this.log.trace("Cache miss for route", {
-				key,
-				route: route.path
-			});
-		}
-	});
-	onSend = $hook({
-		on: "server:onSend",
-		handler: async ({ route, request }) => {
-			const cache = route.cache;
-			const shouldStore = this.shouldStore(cache);
-			const shouldUseEtag = this.shouldUseEtag(cache);
-			if (request.reply.headers.etag) return;
-			if (!shouldStore && shouldUseEtag && request.reply.body != null && (typeof request.reply.body === "string" || Buffer.isBuffer(request.reply.body))) {
-				const generatedEtag = this.generateETag(request.reply.body);
-				if (request.headers["if-none-match"] === generatedEtag) {
-					request.reply.status = 304;
-					request.reply.body = void 0;
-					request.reply.setHeader("etag", generatedEtag);
-					this.log.trace("ETag match on send, returning 304", {
-						route: route.path,
-						etag: generatedEtag
-					});
-					return;
-				}
-			}
-		}
-	});
-	onResponse = $hook({
-		on: "server:onResponse",
-		priority: "first",
-		handler: async ({ route, request, response }) => {
-			const cache = route.cache;
-			const cacheControl = this.buildCacheControlHeader(cache);
-			if (cacheControl) response.headers["cache-control"] = cacheControl;
-			const shouldStore = this.shouldStore(cache);
-			const shouldUseEtag = this.shouldUseEtag(cache);
-			if (!shouldStore && !shouldUseEtag) return;
-			if (typeof response.body !== "string") return;
-			if (response.status && response.status >= 400) return;
-			const key = this.createCacheKey(route, request);
-			const generatedEtag = this.generateETag(response.body);
-			const lastModified = this.time.toISOString();
-			response.headers ??= {};
-			if (shouldStore) {
-				this.log.trace("Storing response", {
-					key,
-					route: route.path,
-					cache: !!cache,
-					etag: shouldUseEtag
-				});
-				await this.cache.set(key, {
-					body: response.body,
-					status: response.status,
-					contentType: response.headers?.["content-type"],
-					lastModified,
-					hash: generatedEtag
-				});
-			}
-			if (shouldUseEtag) {
-				response.headers.etag = generatedEtag;
-				response.headers["last-modified"] = lastModified;
-			}
-		}
-	});
-	buildCacheControlHeader(cache) {
-		if (!cache) return;
-		if (cache === true || typeof cache === "string" || typeof cache === "number") return;
-		const control = cache.control;
-		if (!control) return;
-		if (typeof control === "string") return control;
-		if (control === true) return "public, max-age=300";
-		const directives = [];
-		if (control.public) directives.push("public");
-		if (control.private) directives.push("private");
-		if (control.noCache) directives.push("no-cache");
-		if (control.noStore) directives.push("no-store");
-		if (control.maxAge !== void 0) {
-			const maxAgeSeconds = this.durationToSeconds(control.maxAge);
-			directives.push(`max-age=${maxAgeSeconds}`);
-		}
-		if (control.sMaxAge !== void 0) {
-			const sMaxAgeSeconds = this.durationToSeconds(control.sMaxAge);
-			directives.push(`s-maxage=${sMaxAgeSeconds}`);
-		}
-		if (control.mustRevalidate) directives.push("must-revalidate");
-		if (control.proxyRevalidate) directives.push("proxy-revalidate");
-		if (control.immutable) directives.push("immutable");
-		return directives.length > 0 ? directives.join(", ") : void 0;
-	}
-	durationToSeconds(duration) {
-		if (typeof duration === "number") return duration;
-		return this.time.duration(duration).asSeconds();
-	}
-	shouldStore(cache) {
-		if (!cache) return false;
-		if (cache === true) return true;
-		if (typeof cache === "object" && cache.store) return true;
-		return false;
-	}
-	shouldUseEtag(cache) {
-		if (cache === true) return true;
-		if (typeof cache === "object" && cache.etag) return true;
-		return false;
-	}
-	createCacheKey(route, config) {
-		const params = [];
-		for (const [key, value] of Object.entries(config?.params ?? {})) params.push(`${key}=${value}`);
-		for (const [key, value] of Object.entries(config?.query ?? {})) params.push(`${key}=${value}`);
-		return `${route.method}:${route.path.replaceAll(":", "")}:${params.join(",").replaceAll(":", "")}`;
-	}
-};
-
-//#endregion
-//#region src/server-cache/index.ts
-/**
-* Plugin for Alepha Server that provides server-side caching capabilities.
-* It uses the Alepha Cache module to cache responses from server actions ($action).
-* It also provides a ETag-based cache invalidation mechanism.
-*
-* @example
-* ```ts
-* import { Alepha } from "alepha";
-* import { $action } from "alepha/server";
-* import { AlephaServerCache } from "alepha/server/cache";
-*
-* class ApiServer {
-*   hello = $action({
-*     cache: true,
-*     handler: () => "Hello, World!",
-*   });
-* }
-*
-* const alepha = Alepha.create()
-*   .with(AlephaServerCache)
-*   .with(ApiServer);
-*
-* run(alepha);
-* ```
-*
-* @see {@link ServerCacheProvider}
-* @module alepha.server.cache
-*/
-const AlephaServerCache = $module({
-	name: "alepha.server.cache",
-	services: [AlephaCache, ServerCacheProvider]
-});
-
-//#endregion
-//#region src/server-static/descriptors/$serve.ts
-/**
-* Create a new static file handler.
-*/
-const $serve = (options = {}) => {
-	return createDescriptor(ServeDescriptor, options);
-};
-var ServeDescriptor = class extends Descriptor {};
-$serve[KIND] = ServeDescriptor;
-
-//#endregion
-//#region src/server-static/providers/ServerStaticProvider.ts
-var ServerStaticProvider = class {
-	alepha = $inject(Alepha);
-	routerProvider = $inject(ServerRouterProvider);
-	dateTimeProvider = $inject(DateTimeProvider);
-	fileDetector = $inject(FileDetector);
-	log = $logger();
-	directories = [];
-	configure = $hook({
-		on: "configure",
-		handler: async () => {
-			await Promise.all(this.alepha.descriptors($serve).map((it) => this.createStaticServer(it.options)));
-		}
-	});
-	async createStaticServer(options) {
-		const prefix = options.path ?? "/";
-		let root = options.root ?? process.cwd();
-		if (!isAbsolute(root)) root = join(process.cwd(), root);
-		this.log.debug("Serve static files", {
-			prefix,
-			root
-		});
-		await stat(root);
-		const files = await this.getAllFiles(root, options.ignoreDotEnvFiles);
-		const routes = await Promise.all(files.map(async (file) => {
-			const path = file.replace(root, "").replace(/\\/g, "/");
-			this.log.trace(`Mount ${join(prefix, path)} -> ${join(root, path)}`);
-			return {
-				path: join(prefix, encodeURI(path)),
-				handler: await this.createFileHandler(join(root, path), options)
-			};
-		}));
-		for (const route of routes) {
-			this.routerProvider.createRoute(route);
-			if (options.indexFallback !== false && route.path.endsWith("index.html")) this.routerProvider.createRoute({
-				path: route.path.replace(/index\.html$/, ""),
-				handler: route.handler
-			});
-		}
-		this.directories.push({
-			options,
-			files: files.map((file) => file.replace(root, "").replace(/\\/g, "/"))
-		});
-		if (options.historyApiFallback) this.routerProvider.createRoute({
-			path: join(prefix, "*").replace(/\\/g, "/"),
-			handler: async (request) => {
-				const { reply } = request;
-				if (request.url.pathname.includes(".")) {
-					reply.headers["content-type"] = "text/plain";
-					reply.body = "Not Found";
-					reply.status = 404;
-					return;
-				}
-				reply.headers["content-type"] = "text/html";
-				reply.status = 200;
-				return createReadStream(join(root, "index.html"));
-			}
-		});
-	}
-	async createFileHandler(filepath, options) {
-		const filename = basename(filepath);
-		const hasGzip = await access(`${filepath}.gz`).then(() => true).catch(() => false);
-		const hasBr = await access(`${filepath}.br`).then(() => true).catch(() => false);
-		const fileStat = await stat(filepath);
-		const lastModified = fileStat.mtime.toUTCString();
-		const etag = `"${fileStat.size}-${fileStat.mtime.getTime()}"`;
-		const contentType = this.fileDetector.getContentType(filename);
-		const cacheControl = this.getCacheControl(filename, options);
-		return async (request) => {
-			const { headers, reply } = request;
-			let path = filepath;
-			const encoding = headers["accept-encoding"];
-			if (encoding) {
-				if (hasBr && encoding.includes("br")) {
-					reply.headers["content-encoding"] = "br";
-					path += ".br";
-				} else if (hasGzip && encoding.includes("gzip")) {
-					reply.headers["content-encoding"] = "gzip";
-					path += ".gz";
-				}
-			}
-			reply.headers["content-type"] = contentType;
-			reply.headers["accept-ranges"] = "bytes";
-			reply.headers["last-modified"] = lastModified;
-			if (cacheControl) {
-				reply.headers["cache-control"] = `public, max-age=${cacheControl.maxAge}`;
-				if (cacheControl.immutable) reply.headers["cache-control"] += ", immutable";
-			}
-			reply.headers.etag = etag;
-			if (headers["if-none-match"] === etag || headers["if-modified-since"] === lastModified) {
-				reply.status = 304;
-				return;
-			}
-			return createReadStream(path);
-		};
-	}
-	getCacheFileTypes() {
-		return [
-			".js",
-			".css",
-			".woff",
-			".woff2",
-			".ttf",
-			".eot",
-			".otf",
-			".jpg",
-			".jpeg",
-			".png",
-			".svg",
-			".gif"
-		];
-	}
-	getCacheControl(filename, options) {
-		if (!options.cacheControl) return;
-		const fileTypes = options.cacheControl.fileTypes ?? this.getCacheFileTypes();
-		for (const type of fileTypes) if (filename.endsWith(type)) return {
-			immutable: options.cacheControl.immutable ?? true,
-			maxAge: this.dateTimeProvider.duration(options.cacheControl.maxAge ?? [30, "days"]).as("seconds")
-		};
-	}
-	async getAllFiles(dir, ignoreDotEnvFiles = true) {
-		const entries = await readdir(dir, { withFileTypes: true });
-		return (await Promise.all(entries.map((dirent) => {
-			if (ignoreDotEnvFiles && dirent.name.startsWith(".")) return [];
-			const fullPath = join(dir, dirent.name);
-			return dirent.isDirectory() ? this.getAllFiles(fullPath) : fullPath;
-		}))).flat();
-	}
-};
-
-//#endregion
-//#region src/server-static/index.ts
-/**
-* Create static file server with `$static()`.
-*
-* @see {@link ServerStaticProvider}
-* @module alepha.server.static
-*/
-const AlephaServerStatic = $module({
-	name: "alepha.server.static",
-	descriptors: [$serve],
-	services: [AlephaServer, ServerStaticProvider]
-});
-
-//#endregion
-//#region src/server-swagger/descriptors/$swagger.ts
+//#region src/server-swagger/primitives/$swagger.ts
 /**
-* Creates an OpenAPI/Swagger documentation descriptor with interactive UI.
+* Creates an OpenAPI/Swagger documentation primitive with interactive UI.
 *
-* Automatically generates API documentation from your $action descriptors and serves
+* Automatically generates API documentation from your $action primitives and serves
 * an interactive Swagger UI for testing endpoints. Supports customization, tag filtering,
 * and OAuth configuration.
 *
@@ -737,10 +34,10 @@ const AlephaServerStatic = $module({
 * ```
 */
 const $swagger = (options = {}) => {
-	return createDescriptor(SwaggerDescriptor, options);
+	return createPrimitive(SwaggerPrimitive, options);
 };
-var SwaggerDescriptor = class extends Descriptor {};
-$swagger[KIND] = SwaggerDescriptor;
+var SwaggerPrimitive = class extends Primitive {};
+$swagger[KIND] = SwaggerPrimitive;
 
 //#endregion
 //#region src/server-swagger/providers/ServerSwaggerProvider.ts
@@ -765,14 +62,14 @@ var ServerSwaggerProvider = class {
 		on: "configure",
 		priority: "last",
 		handler: async (alepha) => {
-			const options = alepha.descriptors($swagger)?.[0]?.options;
+			const options = alepha.primitives($swagger)?.[0]?.options;
 			if (!options) return;
 			this.json = await this.createSwagger(options);
 		}
 	});
 	async createSwagger(options) {
 		if (options.disabled) return;
-		const json = this.configureOpenApi(this.alepha.descriptors($action), options);
+		const json = this.configureOpenApi(this.alepha.primitives($action), options);
 		if (options.rewrite) options.rewrite(json);
 		const prefix = options.prefix ?? "/docs";
 		this.configureSwaggerApi(prefix, json);
@@ -940,7 +237,7 @@ window.onload = function() {
 };
 		`.trim();
 		const dirname = fileURLToPath(import.meta.url);
-		const root = await this.getAssetPath(ui.root, join(dirname, "../../assets/swagger-ui"), join(dirname, "../../../../assets/swagger-ui"));
+		const root = await this.getAssetPath(ui.root, join(dirname, "../../assets/swagger-ui"), join(dirname, "../../../assets/swagger-ui"), join(dirname, "../../../../assets/swagger-ui"));
 		if (!root) {
 			this.log.warn(`Failed to locate Swagger UI assets for path ${prefix}`);
 			return;
@@ -1001,17 +298,17 @@ window.onload = function() {
 */
 const AlephaServerSwagger = $module({
 	name: "alepha.server.swagger",
-	descriptors: [$swagger],
+	primitives: [$swagger],
 	services: [ServerSwaggerProvider],
 	register: (alepha) => {
 		alepha.with(AlephaServer);
 		alepha.with(AlephaServerCache);
 		alepha.with(AlephaServerStatic);
 		alepha.with(ServerSwaggerProvider);
-		alepha.state.push("alepha.build.assets", "alepha");
+		alepha.store.push("alepha.build.assets", "alepha");
 	}
 });
 
 //#endregion
-export { $swagger, AlephaServerSwagger, ServerSwaggerProvider, SwaggerDescriptor, swaggerOptions };
+export { $swagger, AlephaServerSwagger, ServerSwaggerProvider, SwaggerPrimitive, swaggerOptions };
 //# sourceMappingURL=index.js.map