gorsee 0.2.3 → 0.2.5

package/dist-pkg/server/cache-utils.js

@@ -0,0 +1,26 @@
+export function createNamespacedCacheStore(store, namespace) {
+  const prefix = `${namespace}:`;
+  return {
+    get: (key) => store.get(prefix + key),
+    set: async (key, entry) => {
+      await store.set(prefix + key, entry);
+    },
+    delete: async (key) => {
+      await store.delete(prefix + key);
+    },
+    clear: async () => {
+      const keys = await store.keys();
+      for await (const key of keys)
+        if (key.startsWith(prefix))
+          await store.delete(key);
+    },
+    keys: async function* () {
+      const keys = await store.keys();
+      for await (const key of keys) {
+        if (!key.startsWith(prefix))
+          continue;
+        yield key.slice(prefix.length);
+      }
+    }
+  };
+}

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

@@ -0,0 +1,33 @@
+import type { MiddlewareFn } from "./middleware.js";
+export type CacheMode = "private" | "public" | "shared" | "no-store";
+export interface CacheOptions {
+    maxAge: number;
+    staleWhileRevalidate?: number;
+    mode?: CacheMode;
+    vary?: string[];
+    includeAuthHeaders?: boolean;
+    key?: (url: URL) => string;
+    store?: CacheStore;
+}
+type Awaitable<T> = T | Promise<T>;
+export interface CacheEntry {
+    body: string;
+    headers: Record<string, string>;
+    status: number;
+    createdAt: number;
+    revalidating?: boolean;
+}
+export interface CacheStore {
+    get(key: string): Awaitable<CacheEntry | undefined>;
+    set(key: string, entry: CacheEntry): Awaitable<void>;
+    delete(key: string): Awaitable<void>;
+    clear(): Awaitable<void>;
+    keys(): Awaitable<Iterable<string> | AsyncIterable<string>>;
+}
+export declare function createMemoryCacheStore(): CacheStore;
+export declare function resolveCacheMode(options: CacheOptions): CacheMode;
+export declare function shouldIncludeAuthHeadersForCache(options: CacheOptions, mode?: CacheMode): boolean;
+export declare function routeCache(options: CacheOptions): MiddlewareFn;
+export declare function invalidateCache(path: string): Promise<void>;
+export declare function clearCache(): Promise<void>;
+export {};

package/dist-pkg/server/cache.js

@@ -0,0 +1,236 @@
+import { emitAIEvent } from "../ai/index.js";
+export function createMemoryCacheStore() {
+  const store = new Map;
+  return {
+    get: (key) => store.get(key),
+    set: (key, entry) => {
+      store.set(key, entry);
+    },
+    delete: (key) => {
+      store.delete(key);
+    },
+    clear: () => {
+      store.clear();
+    },
+    keys: () => store.keys()
+  };
+}
+const defaultCacheStore = createMemoryCacheStore(), DEFAULT_AUTH_VARY = ["Cookie", "Authorization"], DEFAULT_SURFACE_VARY = ["Accept", "X-Gorsee-Navigate"];
+export function resolveCacheMode(options) {
+  if (options.mode)
+    return options.mode;
+  if (options.includeAuthHeaders === !1)
+    return "public";
+  return "private";
+}
+export function shouldIncludeAuthHeadersForCache(options, mode = resolveCacheMode(options)) {
+  if (typeof options.includeAuthHeaders === "boolean")
+    return options.includeAuthHeaders;
+  return mode === "private";
+}
+function buildKey(url, vary, request, customKey) {
+  const base = customKey ? customKey(url) : url.pathname + url.search;
+  if (vary.length === 0)
+    return base;
+  const varyParts = vary.map((h) => `${h}=${request.headers.get(h) ?? ""}`).join("&");
+  return `${base}?__vary=${varyParts}`;
+}
+export function routeCache(options) {
+  const {
+    maxAge,
+    staleWhileRevalidate = 0,
+    vary = [],
+    key: customKey,
+    store = defaultCacheStore
+  } = options, mode = resolveCacheMode(options), includeAuthHeaders = shouldIncludeAuthHeadersForCache(options, mode), normalizedVary = normalizeVaryHeaders([
+    ...DEFAULT_SURFACE_VARY,
+    ...includeAuthHeaders ? DEFAULT_AUTH_VARY : [],
+    ...vary
+  ]);
+  return async (ctx, next) => {
+    if (ctx.request.method !== "GET")
+      return next();
+    if (mode === "no-store") {
+      const response = await next(), headers = new Headers(response.headers);
+      headers.set("Cache-Control", "no-store");
+      setVaryHeaderObject(headers, normalizedVary);
+      return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+    const cacheKey = buildKey(ctx.url, normalizedVary, ctx.request, customKey), entry = await store.get(cacheKey), now = Date.now();
+    if (entry) {
+      const age = (now - entry.createdAt) / 1000;
+      if (age < maxAge) {
+        emitAIEvent({
+          kind: "cache.hit",
+          severity: "info",
+          source: "runtime",
+          message: "cache hit",
+          requestId: typeof ctx.locals.requestId === "string" ? ctx.locals.requestId : void 0,
+          traceId: typeof ctx.locals.traceId === "string" ? ctx.locals.traceId : void 0,
+          spanId: typeof ctx.locals.spanId === "string" ? ctx.locals.spanId : void 0,
+          route: ctx.url.pathname,
+          data: { cacheKey, ageSeconds: Math.floor(age), mode }
+        });
+        return new Response(entry.body, {
+          status: entry.status,
+          headers: withVaryHeaders(entry.headers, normalizedVary, {
+            "X-Cache": "HIT",
+            Age: String(Math.floor(age))
+          })
+        });
+      }
+      if (age < maxAge + staleWhileRevalidate && !entry.revalidating) {
+        entry.revalidating = !0;
+        emitAIEvent({
+          kind: "cache.stale",
+          severity: "warn",
+          source: "runtime",
+          message: "stale cache entry served",
+          requestId: typeof ctx.locals.requestId === "string" ? ctx.locals.requestId : void 0,
+          traceId: typeof ctx.locals.traceId === "string" ? ctx.locals.traceId : void 0,
+          spanId: typeof ctx.locals.spanId === "string" ? ctx.locals.spanId : void 0,
+          route: ctx.url.pathname,
+          data: { cacheKey, ageSeconds: Math.floor(age), mode }
+        });
+        revalidate(cacheKey, store, next);
+        return new Response(entry.body, {
+          status: entry.status,
+          headers: withVaryHeaders(entry.headers, normalizedVary, {
+            "X-Cache": "STALE",
+            Age: String(Math.floor(age))
+          })
+        });
+      }
+    }
+    emitAIEvent({
+      kind: "cache.miss",
+      severity: "info",
+      source: "runtime",
+      message: "cache miss",
+      requestId: typeof ctx.locals.requestId === "string" ? ctx.locals.requestId : void 0,
+      traceId: typeof ctx.locals.traceId === "string" ? ctx.locals.traceId : void 0,
+      spanId: typeof ctx.locals.spanId === "string" ? ctx.locals.spanId : void 0,
+      route: ctx.url.pathname,
+      data: { cacheKey, mode }
+    });
+    const response = await next();
+    if (response.status === 200 && isCacheableResponse(response, mode)) {
+      const body = await response.text(), headers = {};
+      response.headers.forEach((v, k) => {
+        headers[k] = v;
+      });
+      setVaryHeader(headers, normalizedVary);
+      setCacheControlHeader(headers, mode, maxAge, staleWhileRevalidate);
+      await store.set(cacheKey, { body, headers, status: response.status, createdAt: now });
+      return new Response(body, {
+        status: response.status,
+        headers: { ...headers, "X-Cache": "MISS" }
+      });
+    }
+    emitAIEvent({
+      kind: "cache.skip",
+      severity: "debug",
+      source: "runtime",
+      message: "response not cached",
+      requestId: typeof ctx.locals.requestId === "string" ? ctx.locals.requestId : void 0,
+      traceId: typeof ctx.locals.traceId === "string" ? ctx.locals.traceId : void 0,
+      spanId: typeof ctx.locals.spanId === "string" ? ctx.locals.spanId : void 0,
+      route: ctx.url.pathname,
+      data: { cacheKey, status: response.status, mode }
+    });
+    return response;
+  };
+}
+async function revalidate(key, store, next) {
+  try {
+    const response = await next();
+    if (response.status === 200) {
+      const body = await response.text(), headers = {};
+      response.headers.forEach((v, k) => {
+        headers[k] = v;
+      });
+      await store.set(key, { body, headers, status: response.status, createdAt: Date.now() });
+    }
+  } catch {
+    const entry = await store.get(key);
+    if (entry)
+      entry.revalidating = !1;
+  }
+}
+export async function invalidateCache(path) {
+  const keys = await defaultCacheStore.keys();
+  for await (const key of keys)
+    if (key.startsWith(path))
+      await defaultCacheStore.delete(key);
+}
+export async function clearCache() {
+  await defaultCacheStore.clear();
+}
+function normalizeVaryHeaders(headers) {
+  const seen = new Set, normalized = [];
+  for (const header of headers) {
+    const trimmed = header.trim();
+    if (!trimmed)
+      continue;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    normalized.push(canonicalizeHeaderName(trimmed));
+  }
+  normalized.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
+  return normalized;
+}
+function setVaryHeader(headers, vary) {
+  if (vary.length === 0)
+    return;
+  const existing = headers.vary ?? headers.Vary, merged = normalizeVaryHeaders([
+    ...existing ? existing.split(",") : [],
+    ...vary
+  ]);
+  headers.Vary = merged.join(", ");
+  delete headers.vary;
+}
+function setVaryHeaderObject(headers, vary) {
+  if (vary.length === 0)
+    return;
+  const existing = headers.get("Vary"), merged = normalizeVaryHeaders([
+    ...existing ? existing.split(",") : [],
+    ...vary
+  ]);
+  headers.set("Vary", merged.join(", "));
+}
+function withVaryHeaders(headers, vary, extraHeaders) {
+  const merged = { ...headers, ...extraHeaders };
+  setVaryHeader(merged, vary);
+  return merged;
+}
+function isCacheableResponse(response, mode) {
+  if (response.headers.has("Set-Cookie"))
+    return !1;
+  const cacheControl = response.headers.get("Cache-Control")?.toLowerCase() ?? "";
+  if (cacheControl.includes("no-store"))
+    return !1;
+  if (mode === "public" || mode === "shared")
+    return !cacheControl.includes("private");
+  return !0;
+}
+function setCacheControlHeader(headers, mode, maxAge, staleWhileRevalidate) {
+  if (mode === "no-store") {
+    headers["Cache-Control"] = "no-store";
+    return;
+  }
+  const directives = [mode === "private" ? "private" : "public", `max-age=${maxAge}`];
+  if (mode === "shared")
+    directives.push(`s-maxage=${maxAge}`);
+  if (staleWhileRevalidate > 0)
+    directives.push(`stale-while-revalidate=${staleWhileRevalidate}`);
+  headers["Cache-Control"] = directives.join(", ");
+}
+function canonicalizeHeaderName(header) {
+  return header.toLowerCase().split("-").map((segment) => segment ? segment[0].toUpperCase() + segment.slice(1) : segment).join("-");
+}

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

@@ -0,0 +1,2 @@
+import type { MiddlewareFn } from "./middleware.js";
+export declare function compress(): MiddlewareFn;

package/dist-pkg/server/compress.js

@@ -0,0 +1,49 @@
+const COMPRESSIBLE_TYPES = new Set([
+  "text/html",
+  "text/css",
+  "text/javascript",
+  "application/javascript",
+  "application/json",
+  "text/xml",
+  "application/xml",
+  "image/svg+xml"
+]);
+function isCompressible(contentType) {
+  if (!contentType)
+    return !1;
+  const type = contentType.split(";")[0].trim();
+  return COMPRESSIBLE_TYPES.has(type);
+}
+export function compress() {
+  return async (_ctx, next) => {
+    const response = await next(), contentType = response.headers.get("content-type");
+    if (!isCompressible(contentType))
+      return response;
+    if (response.headers.has("content-encoding"))
+      return response;
+    if (!response.body)
+      return response;
+    const acceptEncoding = _ctx.request.headers.get("accept-encoding") ?? "";
+    if (acceptEncoding.includes("gzip")) {
+      const compressed = response.body.pipeThrough(new CompressionStream("gzip")), headers = new Headers(response.headers);
+      headers.set("Content-Encoding", "gzip");
+      headers.delete("Content-Length");
+      return new Response(compressed, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+    if (acceptEncoding.includes("deflate")) {
+      const compressed = response.body.pipeThrough(new CompressionStream("deflate")), headers = new Headers(response.headers);
+      headers.set("Content-Encoding", "deflate");
+      headers.delete("Content-Length");
+      return new Response(compressed, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+      });
+    }
+    return response;
+  };
+}

package/dist-pkg/server/endpoint-execution.d.ts

@@ -0,0 +1,28 @@
+import { type Context, type MiddlewareFn } from "./middleware.js";
+import { type RequestExecutionKind, type RequestExecutionPolicy, type RequestMetadata } from "./request-policy.js";
+import { type RequestSecurityPolicy } from "./request-security-policy.js";
+export interface EndpointExecutionTrace {
+    requestId?: string;
+    traceId?: string;
+    spanId?: string;
+    parentSpanId?: string;
+}
+export interface EndpointExecutionContext {
+    ctx: Context;
+    metadata: RequestMetadata;
+    requestPolicy: RequestExecutionPolicy;
+    securityPolicy: RequestSecurityPolicy;
+}
+export interface EndpointExecutionOptions {
+    request: Request;
+    kind: RequestExecutionKind;
+    params?: Record<string, string>;
+    trustedOrigin?: string;
+    trustForwardedHeaders?: boolean;
+    trustedForwardedHops?: number;
+    securityPolicy?: RequestSecurityPolicy;
+    middlewares?: MiddlewareFn[];
+    trace?: EndpointExecutionTrace;
+    handler: (context: EndpointExecutionContext) => Promise<Response>;
+}
+export declare function executeEndpointRequest(options: EndpointExecutionOptions): Promise<Response>;

package/dist-pkg/server/endpoint-execution.js

@@ -0,0 +1,37 @@
+import { createContext, runMiddlewareChain } from "./middleware.js";
+import {
+  attachRequestMetadata,
+  resolveRequestExecutionPolicy,
+  resolveRequestMetadata,
+  validateRequestPolicy
+} from "./request-policy.js";
+import {
+  createRequestSecurityPolicy,
+  validateRequestSecurityPolicy
+} from "./request-security-policy.js";
+import { createTraceIds } from "../ai/index.js";
+export async function executeEndpointRequest(options) {
+  const trace = options.trace?.requestId && options.trace?.traceId && options.trace?.spanId ? options.trace : createTraceIds(options.trace), securityPolicy = options.securityPolicy ?? createRequestSecurityPolicy({
+    trustedOrigin: options.trustedOrigin,
+    trustForwardedHeaders: options.trustForwardedHeaders,
+    trustedForwardedHops: options.trustedForwardedHops
+  }), requestPolicy = resolveRequestExecutionPolicy(options.kind), ctx = createContext(options.request, options.params ?? {}, {
+    trustedOrigin: securityPolicy.trustedOrigin
+  }), metadata = resolveRequestMetadata(options.request, {
+    trustedOrigin: securityPolicy.trustedOrigin,
+    kind: options.kind,
+    visibility: requestPolicy.visibility,
+    trustForwardedHeaders: securityPolicy.trustForwardedHeaders,
+    trustedForwardedHops: securityPolicy.trustedForwardedHops
+  });
+  ctx.locals.requestId = trace.requestId;
+  ctx.locals.traceId = trace.traceId;
+  ctx.locals.spanId = trace.spanId;
+  if (trace.parentSpanId)
+    ctx.locals.parentSpanId = trace.parentSpanId;
+  attachRequestMetadata(ctx.locals, metadata, requestPolicy);
+  const violation = validateRequestSecurityPolicy(metadata, requestPolicy, securityPolicy) ?? validateRequestPolicy(metadata, requestPolicy);
+  if (violation)
+    return violation;
+  return runMiddlewareChain(options.middlewares ?? [], ctx, () => options.handler({ ctx, metadata, requestPolicy, securityPolicy }));
+}

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

@@ -0,0 +1,3 @@
+export declare function generateETag(size: number, mtimeMs: number): string;
+export declare function fileETag(filePath: string): Promise<string | null>;
+export declare function isNotModified(request: Request, etag: string): boolean;

package/dist-pkg/server/etag.js

@@ -0,0 +1,18 @@
+import { stat } from "node:fs/promises";
+export function generateETag(size, mtimeMs) {
+  return `W/"${size.toString(16)}-${Math.floor(mtimeMs).toString(16)}"`;
+}
+export async function fileETag(filePath) {
+  try {
+    const s = await stat(filePath);
+    return generateETag(s.size, s.mtimeMs);
+  } catch {
+    return null;
+  }
+}
+export function isNotModified(request, etag) {
+  const ifNoneMatch = request.headers.get("if-none-match");
+  if (!ifNoneMatch)
+    return !1;
+  return ifNoneMatch.split(",").some((t) => t.trim() === etag);
+}

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

@@ -0,0 +1,16 @@
+import type { Context, MiddlewareFn } from "./middleware.js";
+type GuardFn = (ctx: Context) => boolean | Promise<boolean>;
+interface GuardOptions {
+    onFail?: (ctx: Context) => Response | Promise<Response>;
+}
+/** Create a guard middleware from a predicate */
+export declare function createGuard(check: GuardFn, options?: GuardOptions): MiddlewareFn;
+/** Guard: require authenticated session */
+export declare function requireAuth(loginPath?: string): MiddlewareFn;
+/** Guard: require specific role (reads from session.data.role) */
+export declare function requireRole(role: string, options?: GuardOptions): MiddlewareFn;
+/** Guard: combine multiple guards (all must pass) */
+export declare function allGuards(...guards: MiddlewareFn[]): MiddlewareFn;
+/** Guard: any one guard passing is sufficient */
+export declare function anyGuard(...guards: MiddlewareFn[]): MiddlewareFn;
+export {};

package/dist-pkg/server/guard.js

@@ -0,0 +1,45 @@
+const DEFAULT_DENY = (_ctx) => new Response("Forbidden", { status: 403 });
+export function createGuard(check, options) {
+  const onFail = options?.onFail ?? DEFAULT_DENY;
+  return async (ctx, next) => {
+    if (!await check(ctx))
+      return onFail(ctx);
+    return next();
+  };
+}
+export function requireAuth(loginPath = "/login") {
+  return createGuard((ctx) => !!ctx.locals.session, { onFail: (ctx) => ctx.redirect(loginPath) });
+}
+export function requireRole(role, options) {
+  return createGuard((ctx) => {
+    return ctx.locals.session?.data?.role === role;
+  }, options);
+}
+export function allGuards(...guards) {
+  return async (ctx, next) => {
+    for (const guard of guards) {
+      let passed = !1;
+      const result = await guard(ctx, async () => {
+        passed = !0;
+        return new Response(null);
+      });
+      if (!passed)
+        return result;
+    }
+    return next();
+  };
+}
+export function anyGuard(...guards) {
+  return async (ctx, next) => {
+    for (const guard of guards) {
+      let passed = !1;
+      await guard(ctx, async () => {
+        passed = !0;
+        return new Response(null);
+      });
+      if (passed)
+        return next();
+    }
+    return new Response("Forbidden", { status: 403 });
+  };
+}

package/dist-pkg/server/html-shell.d.ts

@@ -0,0 +1,12 @@
+export interface HTMLWrapOptions {
+    title?: string;
+    clientScript?: string;
+    loaderData?: unknown;
+    params?: Record<string, string>;
+    cssFiles?: string[];
+    headElements?: string[];
+    bodyPrefix?: string[];
+    bodySuffix?: string[];
+}
+export declare function generateNonce(): string;
+export declare function wrapHTML(body: string, nonce: string | undefined, options?: HTMLWrapOptions): string;

package/dist-pkg/server/html-shell.js

@@ -0,0 +1,52 @@
+export function generateNonce() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return btoa(String.fromCharCode(...bytes));
+}
+export function wrapHTML(body, nonce, options = {}) {
+  const {
+    title = "Gorsee App",
+    clientScript,
+    loaderData,
+    params,
+    cssFiles = [],
+    headElements = [],
+    bodyPrefix = [],
+    bodySuffix = []
+  } = options;
+  let dataScript = "";
+  if (loaderData !== void 0) {
+    const json = JSON.stringify(loaderData).replace(/</g, "\\u003c");
+    dataScript = `
+  <script id="__GORSEE_DATA__" type="application/json"${renderNonceAttr(nonce)}>${json}</script>`;
+  }
+  let paramsScript = "";
+  if (params && Object.keys(params).length > 0)
+    paramsScript = `
+  <script${renderNonceAttr(nonce)}>window.__GORSEE_PARAMS__=${JSON.stringify(params)}</script>`;
+  const clientTag = clientScript ? `
+  <script type="module" src="${clientScript}"${renderNonceAttr(nonce)}></script>` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>${title}</title>
+  <link rel="stylesheet" href="/styles.css" />
+${cssFiles.map((file) => `  <link rel="stylesheet" href="${file}" />`).join(`
+`)}
+${headElements.join(`
+`)}
+</head>
+<body>
+${bodyPrefix.join(`
+`)}
+  <div id="app">${body}</div>${dataScript}${paramsScript}${clientTag}
+${bodySuffix.join(`
+`)}
+</body>
+</html>`;
+}
+function renderNonceAttr(nonce) {
+  return nonce ? ` nonce="${nonce}"` : "";
+}

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

@@ -0,0 +1,36 @@
+export { server, handleRPCRequest, __registerRPC, getRPCHandler, createMemoryRPCRegistry, handleRPCRequestWithRegistry, createMemoryRPCRegistry as createRPCRegistry, type RPCHandler, type RPCRegistry, } from "./rpc.js";
+export { RPC_PROTOCOL_VERSION, RPC_CONTENT_TYPE, RPC_ACCEPTED_CONTENT_TYPES, type RPCRequestEnvelope, type RPCSuccessEnvelope, type RPCErrorEnvelope, type RPCResponseEnvelope, } from "./rpc-protocol.js";
+export { handleRPCRequestWithPolicy, handleRPCWithHeaders, type RPCRequestOptions } from "./request-preflight.js";
+export { middleware, createContext, runMiddlewareChain, type Context, type MiddlewareFn, type NextFn, } from "./middleware.js";
+export { defineAction, handleAction, parseFormData, actionSuccess, actionFailure, type ActionFn, type ActionResult, type ActionReturn, } from "./action.js";
+export { joinRoom, leaveRoom, broadcastToRoom, getRoomSize, createWSContext, type WSContext, type WSHandler } from "./ws.js";
+export { compress } from "./compress.js";
+export { getMimeType } from "./mime.js";
+export { fileETag, generateETag, isNotModified } from "./etag.js";
+export { redirect, RedirectError, type CookieOptions } from "./middleware.js";
+export { createSSEStream, type SSEOptions, type SSEStream } from "./sse.js";
+export { createEventSource, type EventSourceSignal } from "../runtime/event-source.js";
+export { routeCache, invalidateCache, clearCache, createMemoryCacheStore, type CacheOptions, type CacheEntry, type CacheStore, } 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, type JobContext, type JobDefinition, type JobEnqueueOptions, type JobQueue, type JobRunResult, type EnqueuedJob } from "./jobs.js";
+export { setupI18n, loadLocale, getLocale, getLocales, getDefaultLocale, getFallbackLocales, setLocale, t, plural, negotiateLocale, resolveLocaleFromPath, stripLocalePrefix, withLocalePath, buildHreflangLinks, formatNumber, formatDate, formatRelativeTime, type I18nConfig, type LocaleNegotiationInput, type LocaleNegotiationResult, } from "../i18n/index.js";
+export { loadContentCollection, parseFrontmatter, extractExcerpt, queryContent, getContentEntryBySlug, type ContentCollectionOptions, type ContentEntry, type ContentQueryOptions, } from "../content/index.js";
+export { type RedisLikeClient, type NodeRedisClientLike, type IORedisClientLike, createNodeRedisLikeClient, createIORedisLikeClient, deleteExpiredRedisKeys, } from "./redis-client.js";
+export { createAuth, createMemorySessionStore, createNamespacedSessionStore, createRedisSessionStore, createSQLiteSessionStore, createAuthActionTokenManager, createMemoryAuthActionTokenStore, sessionHasRole, sessionHasPermission, type AuthConfig, type AuthEvent, type AuthEventHandler, type AuthActionTokenClaims, type AuthActionTokenPurpose, type AuthActionTokenReplayStore, type PermissionResolver, type Session, type SessionStore, } from "../auth/index.js";
+export { createDB, createPostgresDB, toPostgresSQL, type DB, type PostgresDB, type PostgresClientLike, type PostgresConnectionLike, type PostgresPoolLike, type PostgresQueryResult, runMigrations, createMigration, type MigrationResult, } from "../db/index.js";
+export { securityHeaders, type SecurityConfig, csrfProtection, createCSRFMiddleware, generateCSRFToken, validateCSRFToken, createRateLimiter, createRedisRateLimiter, parseRateLimitWindow, type RateLimiter, type AsyncRateLimiter, type AsyncRateLimitResult, cors, type CORSOptions, } 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, type AIMCPServerOptions, type AIContextPacket, type AIContextBundle, type AIContextSnippet, type AIHealthReport, type AIEvent, type AIEventSeverity, type IDEProjection, type IDEProjectionPaths, type IDEProjectionWatcher, type IDEProjectionWatcherOptions, type AISessionPackConfig, type AISessionPackPaths, type AIStorePaths, type AITraceContext, type AIDiagnostic, type AIObservabilityConfig, type AIBridgeConfig, type AIBridgeServer, type AIBridgeHandler, type AIBridgeServerOptions, type AIBridgeSnapshot, } from "../ai/index.js";
+export { BUILD_MANIFEST_SCHEMA_VERSION, loadBuildManifest, parseBuildManifest, getRouteBuildEntry, getClientBundleForRoute, isPrerenderedRoute, getPrerenderedHtmlPath, type BuildManifest, type BuildManifestRoute, } from "./manifest.js";
+export { attachRequestMetadata, classifyRouteRequest, resolveRequestExecutionPolicy, resolveRequestMetadata, validateRequestPolicy, type RequestExecutionKind, type RequestExecutionPolicy, type RequestAccess, type RequestMetadata, type RequestMutation, type RequestResponseShape, type RouteRequestExecutionKind, type RequestVisibility, } from "./request-policy.js";
+export { createRuntimeRequestPlan, type RuntimeRequestPlanOptions, type RuntimeRequestSurface, } from "./request-surface.js";
+export { dispatchRuntimeRequestPlan, type RuntimeDispatchOptions, type RuntimeDispatchResult, } from "./runtime-dispatch.js";
+export { renderRouteErrorBoundaryResponse, renderRoutePageResponse, renderRoutePartialResponse, } from "./route-response.js";
+export { createRequestSecurityPolicy, validateRequestSecurityPolicy, type RequestSecurityPolicy, type RequestSecurityPolicyOptions, } from "./request-security-policy.js";
+export { executeServerExecution, type ServerExecutionContext, type ServerExecutionKind, type ServerExecutionOptions, } from "./server-execution.js";