gorsee 0.2.3 → 0.2.5

package/dist-pkg/server/index.js

@@ -0,0 +1,170 @@
+export {
+  server,
+  handleRPCRequest,
+  __registerRPC,
+  getRPCHandler,
+  createMemoryRPCRegistry,
+  handleRPCRequestWithRegistry,
+  createMemoryRPCRegistry as createRPCRegistry
+} from "./rpc.js";
+export {
+  RPC_PROTOCOL_VERSION,
+  RPC_CONTENT_TYPE,
+  RPC_ACCEPTED_CONTENT_TYPES
+} from "./rpc-protocol.js";
+export { handleRPCRequestWithPolicy, handleRPCWithHeaders } from "./request-preflight.js";
+export {
+  middleware,
+  createContext,
+  runMiddlewareChain
+} from "./middleware.js";
+export {
+  defineAction,
+  handleAction,
+  parseFormData,
+  actionSuccess,
+  actionFailure
+} from "./action.js";
+export { joinRoom, leaveRoom, broadcastToRoom, getRoomSize, createWSContext } from "./ws.js";
+export { compress } from "./compress.js";
+export { getMimeType } from "./mime.js";
+export { fileETag, generateETag, isNotModified } from "./etag.js";
+export { redirect, RedirectError } from "./middleware.js";
+export { createSSEStream } from "./sse.js";
+export { createEventSource } from "../runtime/event-source.js";
+export {
+  routeCache,
+  invalidateCache,
+  clearCache,
+  createMemoryCacheStore
+} from "./cache.js";
+export { createGuard, requireAuth, requireRole, allGuards, anyGuard } from "./guard.js";
+export { pipe, when, forMethods, forPaths } from "./pipe.js";
+export { createNamespacedCacheStore } from "./cache-utils.js";
+export { createRedisCacheStore } from "./redis-cache-store.js";
+export { createScopedRPCRegistry } from "./rpc-utils.js";
+export { createSQLiteCacheStore } from "./sqlite-cache-store.js";
+export { createMemoryJobQueue, defineJob } from "./jobs.js";
+export {
+  setupI18n,
+  loadLocale,
+  getLocale,
+  getLocales,
+  getDefaultLocale,
+  getFallbackLocales,
+  setLocale,
+  t,
+  plural,
+  negotiateLocale,
+  resolveLocaleFromPath,
+  stripLocalePrefix,
+  withLocalePath,
+  buildHreflangLinks,
+  formatNumber,
+  formatDate,
+  formatRelativeTime
+} from "../i18n/index.js";
+export {
+  loadContentCollection,
+  parseFrontmatter,
+  extractExcerpt,
+  queryContent,
+  getContentEntryBySlug
+} from "../content/index.js";
+export {
+  createNodeRedisLikeClient,
+  createIORedisLikeClient,
+  deleteExpiredRedisKeys
+} from "./redis-client.js";
+export {
+  createAuth,
+  createMemorySessionStore,
+  createNamespacedSessionStore,
+  createRedisSessionStore,
+  createSQLiteSessionStore,
+  createAuthActionTokenManager,
+  createMemoryAuthActionTokenStore,
+  sessionHasRole,
+  sessionHasPermission
+} from "../auth/index.js";
+export {
+  createDB,
+  createPostgresDB,
+  toPostgresSQL,
+  runMigrations,
+  createMigration
+} from "../db/index.js";
+export {
+  securityHeaders,
+  csrfProtection,
+  createCSRFMiddleware,
+  generateCSRFToken,
+  validateCSRFToken,
+  createRateLimiter,
+  createRedisRateLimiter,
+  parseRateLimitWindow,
+  cors
+} from "../security/index.js";
+export { env, getPublicEnv, loadEnv } from "../env/index.js";
+export { log, setLogLevel } from "../log/index.js";
+export {
+  GORSEE_AI_CONTEXT_SCHEMA_VERSION,
+  buildAIHealthReport,
+  buildAIContextBundle,
+  buildIDEProjection,
+  configureAIObservability,
+  createAIMCPServer,
+  createAIContextPacket,
+  createAIBridgeHandler,
+  createAIBridgeServer,
+  createIDEProjectionWatcher,
+  createLineReader,
+  emitAIDiagnostic,
+  emitAIEvent,
+  createTraceIds,
+  readAIDiagnosticsSnapshot,
+  readAIEvents,
+  renderAIContextBundleMarkdown,
+  renderAIContextMarkdown,
+  resolveAISessionPackPaths,
+  resolveIDEProjectionPaths,
+  resolveAIStorePaths,
+  resolveAIObservabilityConfig,
+  runWithAITrace,
+  writeAISessionPack,
+  writeIDEProjection
+} from "../ai/index.js";
+export {
+  BUILD_MANIFEST_SCHEMA_VERSION,
+  loadBuildManifest,
+  parseBuildManifest,
+  getRouteBuildEntry,
+  getClientBundleForRoute,
+  isPrerenderedRoute,
+  getPrerenderedHtmlPath
+} from "./manifest.js";
+export {
+  attachRequestMetadata,
+  classifyRouteRequest,
+  resolveRequestExecutionPolicy,
+  resolveRequestMetadata,
+  validateRequestPolicy
+} from "./request-policy.js";
+export {
+  createRuntimeRequestPlan
+} from "./request-surface.js";
+export {
+  dispatchRuntimeRequestPlan
+} from "./runtime-dispatch.js";
+export {
+  renderRouteErrorBoundaryResponse,
+  renderRoutePageResponse,
+  renderRoutePartialResponse
+} from "./route-response.js";
+export {
+  createRequestSecurityPolicy,
+  validateRequestSecurityPolicy
+} from "./request-security-policy.js";
+export {
+  executeServerExecution
+} from "./server-execution.js";

package/dist-pkg/server/jobs.d.ts

@@ -0,0 +1,41 @@
+type Awaitable<T> = T | Promise<T>;
+export interface JobContext {
+    attempt: number;
+    maxAttempts: number;
+}
+export interface JobDefinition<Payload> {
+    name: string;
+    handler(payload: Payload, context: JobContext): Awaitable<void>;
+}
+export interface JobEnqueueOptions {
+    runAt?: number;
+    maxAttempts?: number;
+    backoffMs?: number;
+}
+export interface EnqueuedJob<Payload = unknown> {
+    id: string;
+    name: string;
+    payload: Payload;
+    runAt: number;
+    attempts: number;
+    maxAttempts: number;
+    backoffMs: number;
+    lastError?: string;
+}
+export interface JobRunResult {
+    id: string;
+    name: string;
+    status: "completed" | "retrying" | "failed";
+    attempts: number;
+    nextRunAt?: number;
+    error?: string;
+}
+export interface JobQueue {
+    enqueue<Payload>(job: JobDefinition<Payload>, payload: Payload, options?: JobEnqueueOptions): Promise<EnqueuedJob<Payload>>;
+    runNext(now?: number): Promise<JobRunResult | null>;
+    drain(now?: number): Promise<JobRunResult[]>;
+    size(): Promise<number>;
+}
+export declare function defineJob<Payload>(name: string, handler: (payload: Payload, context: JobContext) => Awaitable<void>): JobDefinition<Payload>;
+export declare function createMemoryJobQueue(): JobQueue;
+export {};

package/dist-pkg/server/jobs.js

@@ -0,0 +1,81 @@
+export function defineJob(name, handler) {
+  return { name, handler };
+}
+export function createMemoryJobQueue() {
+  const jobs = [];
+  function sortJobs() {
+    jobs.sort((a, b) => a.runAt - b.runAt);
+  }
+  return {
+    async enqueue(job, payload, options = {}) {
+      const enqueued = {
+        id: crypto.randomUUID(),
+        name: job.name,
+        payload,
+        runAt: options.runAt ?? Date.now(),
+        attempts: 0,
+        maxAttempts: options.maxAttempts ?? 3,
+        backoffMs: options.backoffMs ?? 1000,
+        job
+      };
+      jobs.push(enqueued);
+      sortJobs();
+      return enqueued;
+    },
+    async runNext(now = Date.now()) {
+      sortJobs();
+      const nextIndex = jobs.findIndex((entry) => entry.runAt <= now);
+      if (nextIndex === -1)
+        return null;
+      const entry = jobs.splice(nextIndex, 1)[0];
+      entry.attempts += 1;
+      try {
+        await entry.job.handler(entry.payload, {
+          attempt: entry.attempts,
+          maxAttempts: entry.maxAttempts
+        });
+        return {
+          id: entry.id,
+          name: entry.name,
+          status: "completed",
+          attempts: entry.attempts
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        entry.lastError = message;
+        if (entry.attempts < entry.maxAttempts) {
+          entry.runAt = now + entry.backoffMs * entry.attempts;
+          jobs.push(entry);
+          sortJobs();
+          return {
+            id: entry.id,
+            name: entry.name,
+            status: "retrying",
+            attempts: entry.attempts,
+            nextRunAt: entry.runAt,
+            error: message
+          };
+        }
+        return {
+          id: entry.id,
+          name: entry.name,
+          status: "failed",
+          attempts: entry.attempts,
+          error: message
+        };
+      }
+    },
+    async drain(now = Date.now()) {
+      const results = [];
+      for (;; ) {
+        const result = await this.runNext(now);
+        if (!result)
+          return results;
+        results.push(result);
+      }
+    },
+    async size() {
+      return jobs.length;
+    }
+  };
+}

package/dist-pkg/server/manifest.d.ts

@@ -0,0 +1,19 @@
+export declare const BUILD_MANIFEST_SCHEMA_VERSION: 1;
+export interface BuildManifestRoute {
+    js?: string;
+    hasLoader: boolean;
+    prerendered?: boolean;
+}
+export interface BuildManifest {
+    schemaVersion: number;
+    routes: Record<string, BuildManifestRoute>;
+    chunks: string[];
+    prerendered: string[];
+    buildTime: string;
+}
+export declare function loadBuildManifest(distDir: string): Promise<BuildManifest>;
+export declare function parseBuildManifest(raw: string): BuildManifest;
+export declare function getRouteBuildEntry(manifest: BuildManifest, pathname: string): BuildManifestRoute | undefined;
+export declare function getClientBundleForRoute(manifest: BuildManifest, pathname: string): string | undefined;
+export declare function isPrerenderedRoute(manifest: BuildManifest, pathname: string): boolean;
+export declare function getPrerenderedHtmlPath(pathname: string): string;

package/dist-pkg/server/manifest.js

@@ -0,0 +1,36 @@
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+export const BUILD_MANIFEST_SCHEMA_VERSION = 1;
+export async function loadBuildManifest(distDir) {
+  const raw = await readFile(join(distDir, "manifest.json"), "utf-8");
+  return parseBuildManifest(raw);
+}
+export function parseBuildManifest(raw) {
+  const manifest = JSON.parse(raw);
+  validateBuildManifest(manifest);
+  return manifest;
+}
+function validateBuildManifest(manifest) {
+  if (manifest.schemaVersion !== BUILD_MANIFEST_SCHEMA_VERSION)
+    throw Error(`Unsupported build manifest schema version: expected ${BUILD_MANIFEST_SCHEMA_VERSION}, received ${String(manifest.schemaVersion)}`);
+  if (!manifest.routes || typeof manifest.routes !== "object" || Array.isArray(manifest.routes))
+    throw Error("Invalid build manifest: routes must be an object");
+  if (!Array.isArray(manifest.chunks))
+    throw Error("Invalid build manifest: chunks must be an array");
+  if (!Array.isArray(manifest.prerendered))
+    throw Error("Invalid build manifest: prerendered must be an array");
+  if (typeof manifest.buildTime !== "string" || manifest.buildTime.length === 0)
+    throw Error("Invalid build manifest: buildTime must be a non-empty string");
+}
+export function getRouteBuildEntry(manifest, pathname) {
+  return manifest.routes[pathname];
+}
+export function getClientBundleForRoute(manifest, pathname) {
+  return getRouteBuildEntry(manifest, pathname)?.js;
+}
+export function isPrerenderedRoute(manifest, pathname) {
+  return getRouteBuildEntry(manifest, pathname)?.prerendered === !0;
+}
+export function getPrerenderedHtmlPath(pathname) {
+  return pathname === "/" ? "index.html" : join(pathname.slice(1), "index.html");
+}

package/dist-pkg/server/middleware.d.ts

@@ -0,0 +1,39 @@
+export interface CookieOptions {
+    maxAge?: number;
+    expires?: Date;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+}
+export interface Context {
+    request: Request;
+    url: URL;
+    params: Record<string, string>;
+    cookies: Map<string, string>;
+    locals: Record<string, unknown>;
+    /** Response headers to be merged into the final response */
+    responseHeaders: Headers;
+    redirect(url: string, status?: number): Response;
+    setCookie(name: string, value: string, options?: CookieOptions): void;
+    deleteCookie(name: string, options?: Pick<CookieOptions, "path" | "domain">): void;
+    setHeader(name: string, value: string): void;
+}
+export interface ContextOptions {
+    trustedOrigin?: string;
+}
+export type NextFn = () => Promise<Response>;
+export type MiddlewareFn = (ctx: Context, next: NextFn) => Promise<Response>;
+/** Throwable redirect — use in loaders to interrupt and redirect */
+export declare class RedirectError {
+    url: string;
+    status: number;
+    constructor(url: string, status?: number);
+}
+export declare function redirect(url: string, status?: number): never;
+export declare function sanitizeRedirectTarget(target: string, currentUrlOrOrigin: URL | string): string;
+export declare function isAllowedRequestOrigin(request: Request, trustedOrigin?: string): boolean;
+export declare function middleware(fn: MiddlewareFn): MiddlewareFn;
+export declare function createContext(request: Request, params?: Record<string, string>, options?: ContextOptions): Context;
+export declare function runMiddlewareChain(middlewares: MiddlewareFn[], ctx: Context, handler: () => Promise<Response>): Promise<Response>;

package/dist-pkg/server/middleware.js

@@ -0,0 +1,122 @@
+export class RedirectError {
+  url;
+  status;
+  constructor(url, status = 302) {
+    this.url = url;
+    this.status = status;
+  }
+}
+export function redirect(url, status = 302) {
+  throw new RedirectError(url, status);
+}
+export function sanitizeRedirectTarget(target, currentUrlOrOrigin) {
+  const currentUrl = typeof currentUrlOrOrigin === "string" ? new URL(currentUrlOrOrigin) : currentUrlOrOrigin;
+  if (target.startsWith("//"))
+    return "/";
+  if (!/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(target))
+    return target;
+  try {
+    return new URL(target).origin === currentUrl.origin ? target : "/";
+  } catch {
+    return "/";
+  }
+}
+export function isAllowedRequestOrigin(request, trustedOrigin) {
+  const origin = request.headers.get("Origin");
+  if (!origin)
+    return !0;
+  try {
+    const requestOrigin = new URL(origin), expectedOrigin = new URL(trustedOrigin ?? new URL(request.url).origin);
+    return requestOrigin.origin === expectedOrigin.origin;
+  } catch {
+    return !1;
+  }
+}
+export function middleware(fn) {
+  return fn;
+}
+function sanitizeCookiePart(str) {
+  return str.replace(/[\r\n;,]/g, "");
+}
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${sanitizeCookiePart(name)}=${sanitizeCookiePart(value)}`;
+  if (options.maxAge !== void 0)
+    cookie += `; Max-Age=${options.maxAge}`;
+  if (options.expires)
+    cookie += `; Expires=${options.expires.toUTCString()}`;
+  cookie += `; Path=${options.path ?? "/"}`;
+  if (options.domain)
+    cookie += `; Domain=${options.domain}`;
+  if (options.secure)
+    cookie += "; Secure";
+  if (options.httpOnly)
+    cookie += "; HttpOnly";
+  if (options.sameSite)
+    cookie += `; SameSite=${options.sameSite}`;
+  return cookie;
+}
+function parseCookies(request) {
+  const cookieHeader = request.headers.get("cookie") ?? "", cookies = new Map;
+  for (const pair of cookieHeader.split(";")) {
+    const [key, ...rest] = pair.trim().split("=");
+    if (key)
+      cookies.set(key, rest.join("="));
+  }
+  return cookies;
+}
+export function createContext(request, params = {}, options = {}) {
+  const url = new URL(request.url), trustedOrigin = options.trustedOrigin, cookies = parseCookies(request), responseHeaders = new Headers, pendingCookies = [];
+  return {
+    request,
+    url,
+    params,
+    cookies,
+    locals: {},
+    responseHeaders,
+    redirect(target, status = 302) {
+      const safeTarget = sanitizeRedirectTarget(target, trustedOrigin ?? url), res = new Response(null, {
+        status,
+        headers: { Location: safeTarget }
+      });
+      for (const cookie of pendingCookies)
+        res.headers.append("Set-Cookie", cookie);
+      return res;
+    },
+    setCookie(name, value, options) {
+      const cookie = serializeCookie(name, value, options);
+      pendingCookies.push(cookie);
+      responseHeaders.append("Set-Cookie", cookie);
+      cookies.set(name, value);
+    },
+    deleteCookie(name, options) {
+      const cookie = serializeCookie(name, "", {
+        ...options,
+        maxAge: 0,
+        expires: new Date(0)
+      });
+      pendingCookies.push(cookie);
+      responseHeaders.append("Set-Cookie", cookie);
+      cookies.delete(name);
+    },
+    setHeader(name, value) {
+      responseHeaders.set(name, value);
+    }
+  };
+}
+export async function runMiddlewareChain(middlewares, ctx, handler) {
+  let index = 0;
+  const next = async () => {
+    if (index < middlewares.length) {
+      const mw = middlewares[index];
+      index++;
+      return mw(ctx, next);
+    }
+    return handler();
+  }, response = await next();
+  for (const [key, value] of ctx.responseHeaders.entries())
+    if (key.toLowerCase() === "set-cookie")
+      response.headers.append(key, value);
+    else
+      response.headers.set(key, value);
+  return response;
+}

package/dist-pkg/server/mime.d.ts

@@ -0,0 +1 @@
+export declare function getMimeType(path: string): string;

package/{src/server/mime.ts → dist-pkg/server/mime.js}

@@ -1,6 +1,4 @@
-// MIME type detection for static file serving
-
-const MIME_TYPES: Record<string, string> = {
+const MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".css": "text/css; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -10,8 +8,6 @@ const MIME_TYPES: Record<string, string> = {
   ".txt": "text/plain; charset=utf-8",
   ".md": "text/markdown; charset=utf-8",
   ".csv": "text/csv; charset=utf-8",
-
-  // Images
   ".png": "image/png",
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
@@ -20,29 +16,22 @@ const MIME_TYPES: Record<string, string> = {
   ".avif": "image/avif",
   ".svg": "image/svg+xml",
   ".ico": "image/x-icon",
-
-  // Fonts
   ".woff": "font/woff",
   ".woff2": "font/woff2",
   ".ttf": "font/ttf",
   ".otf": "font/otf",
   ".eot": "application/vnd.ms-fontobject",
-
-  // Media
   ".mp4": "video/mp4",
   ".webm": "video/webm",
   ".mp3": "audio/mpeg",
   ".ogg": "audio/ogg",
   ".wav": "audio/wav",
-
-  // Other
   ".pdf": "application/pdf",
   ".zip": "application/zip",
   ".wasm": "application/wasm",
-  ".map": "application/json",
-}
-
-export function getMimeType(path: string): string {
-  const ext = path.slice(path.lastIndexOf(".")).toLowerCase()
-  return MIME_TYPES[ext] ?? "application/octet-stream"
+  ".map": "application/json"
+};
+export function getMimeType(path) {
+  const ext = path.slice(path.lastIndexOf(".")).toLowerCase();
+  return MIME_TYPES[ext] ?? "application/octet-stream";
 }

package/dist-pkg/server/not-found.d.ts

@@ -0,0 +1,6 @@
+import { type HTMLWrapOptions } from "./html-shell.js";
+interface NotFoundOptions extends Pick<HTMLWrapOptions, "bodyPrefix" | "bodySuffix" | "headElements"> {
+    title?: string;
+}
+export declare function renderNotFoundPage(routesDir: string, nonce: string, options?: NotFoundOptions): Promise<string>;
+export {};

package/dist-pkg/server/not-found.js

@@ -0,0 +1,24 @@
+import { join } from "node:path";
+import { stat } from "node:fs/promises";
+import { wrapHTML } from "./html-shell.js";
+export async function renderNotFoundPage(routesDir, nonce, options = {}) {
+  const { title = "404 - Not Found", bodyPrefix, bodySuffix, headElements } = options;
+  try {
+    for (const candidate of ["404.tsx", "404.ts", "404.jsx", "404.js", "404.mjs"]) {
+      const notFoundPath = join(routesDir, candidate);
+      if (!(await stat(notFoundPath).catch(() => null))?.isFile())
+        continue;
+      const mod = await import(notFoundPath);
+      if (typeof mod.default === "function") {
+        const { ssrJsx, renderToString } = await import("../runtime/server.js"), vnode = ssrJsx(mod.default, {}), body = renderToString(vnode);
+        return wrapHTML(body, nonce, { title, bodyPrefix, bodySuffix, headElements });
+      }
+    }
+  } catch {}
+  return wrapHTML("<h1>404</h1><p>Page not found</p>", nonce, {
+    title,
+    bodyPrefix,
+    bodySuffix,
+    headElements
+  });
+}

package/dist-pkg/server/page-render.d.ts

@@ -0,0 +1,29 @@
+import type { Context } from "./middleware.js";
+import type { MatchResult } from "../router/matcher.js";
+type PageModule = Record<string, unknown>;
+export interface ResolvedPageRoute {
+    component: Function;
+    pageComponent: Function;
+    loaderData: unknown;
+    cssFiles: string[];
+    renderMode: string;
+}
+export interface RenderedPage {
+    html: string;
+    headElements: string[];
+    title?: string;
+}
+export interface PartialResponsePayload {
+    html: string;
+    data?: unknown;
+    params?: Record<string, string>;
+    title?: string;
+    css?: string[];
+    script?: string;
+}
+export declare function resolvePageRoute(mod: PageModule, match: MatchResult, ctx: Context): Promise<ResolvedPageRoute | null>;
+export declare function createClientScriptPath(entryFile?: string): string | undefined;
+export declare function renderPageDocument(pageComponent: Function, ctx: Context, params: Record<string, string>, loaderData: unknown): RenderedPage;
+export declare function buildPartialResponsePayload(rendered: RenderedPage, loaderData: unknown, params: Record<string, string>, cssFiles: string[], clientScript?: string): PartialResponsePayload;
+export declare function extractTitle(headElements: string[]): string | undefined;
+export {};