gorsee 0.2.4 → 0.2.6

package/dist-pkg/runtime/image.js

@@ -0,0 +1,144 @@
+const DEFAULT_IMAGE_CONFIG = {
+  widths: [320, 640, 960, 1200, 1600, 2048],
+  formats: ["webp"],
+  quality: 75,
+  fit: "cover"
+};
+function isRemoteSource(src) {
+  return /^https?:\/\//.test(src);
+}
+function matchesRemotePattern(url, pattern) {
+  if (pattern.protocol && url.protocol !== pattern.protocol)
+    return !1;
+  if (pattern.hostname !== url.hostname)
+    return !1;
+  if (!pattern.pathname)
+    return !0;
+  if (pattern.pathname.endsWith("/**")) {
+    const prefix = pattern.pathname.slice(0, -3);
+    return url.pathname.startsWith(prefix);
+  }
+  if (pattern.pathname.endsWith("/*")) {
+    const prefix = pattern.pathname.slice(0, -1);
+    return url.pathname.startsWith(prefix) && !url.pathname.slice(prefix.length).includes("/");
+  }
+  return url.pathname === pattern.pathname;
+}
+export function isAllowedRemoteImage(src, patterns = []) {
+  if (!isRemoteSource(src))
+    return !0;
+  const url = new URL(src);
+  return patterns.some((pattern) => matchesRemotePattern(url, pattern));
+}
+export function defaultImageLoader(params) {
+  const search = new URLSearchParams({
+    src: params.src,
+    w: String(params.width),
+    q: String(params.quality)
+  });
+  if (params.format)
+    search.set("fm", params.format);
+  return `/_gorsee/image?${search.toString()}`;
+}
+export function getImageCandidateWidths(width, widths = DEFAULT_IMAGE_CONFIG.widths) {
+  if (!width)
+    return [...widths];
+  const candidates = widths.filter((candidate) => candidate <= width * 2);
+  if (!candidates.includes(width))
+    candidates.push(width);
+  return [...new Set(candidates)].sort((a, b) => a - b);
+}
+export function buildImageSrcSet(src, width, quality, loader, format, widths = DEFAULT_IMAGE_CONFIG.widths) {
+  const candidates = getImageCandidateWidths(width, widths);
+  if (candidates.length === 0)
+    return;
+  return candidates.map((candidate) => `${loader({ src, width: candidate, quality, format })} ${candidate}w`).join(", ");
+}
+function buildPlaceholderStyle(props) {
+  if (props.placeholder !== "blur" || !props.blurDataURL)
+    return;
+  return {
+    backgroundImage: `url("${props.blurDataURL}")`,
+    backgroundSize: "cover",
+    backgroundPosition: "center"
+  };
+}
+function resolveImageConfig(props) {
+  const config = props.config ?? {};
+  return {
+    widths: config.widths ?? DEFAULT_IMAGE_CONFIG.widths,
+    formats: config.formats ?? DEFAULT_IMAGE_CONFIG.formats,
+    quality: props.quality ?? config.quality ?? DEFAULT_IMAGE_CONFIG.quality,
+    fit: props.fit ?? config.fit ?? DEFAULT_IMAGE_CONFIG.fit,
+    loader: config.loader,
+    remotePatterns: config.remotePatterns
+  };
+}
+export function getImageProps(props) {
+  const {
+    src,
+    alt,
+    width,
+    height,
+    loading: loadingProp,
+    priority,
+    sizes,
+    format,
+    formats,
+    optimize = !0,
+    placeholder,
+    blurDataURL,
+    config,
+    style,
+    ...rest
+  } = props, resolved = resolveImageConfig(props), loading = priority ? "eager" : loadingProp ?? "lazy", fetchpriority = priority ? "high" : void 0, decoding = priority ? "sync" : "async", loader = resolved.loader ?? defaultImageLoader;
+  if (isRemoteSource(src) && !isAllowedRemoteImage(src, resolved.remotePatterns ?? []))
+    throw Error(`Remote image source is not allowed: ${src}`);
+  const shouldOptimize = optimize && Boolean(width), primaryFormat = format ?? formats?.[0] ?? resolved.formats[0], optimizedSrc = shouldOptimize ? loader({ src, width, quality: resolved.quality, format: primaryFormat }) : src, srcSet = shouldOptimize ? buildImageSrcSet(src, width, resolved.quality, loader, primaryFormat, resolved.widths) : void 0, imgProps = {
+    src: optimizedSrc,
+    alt,
+    loading,
+    decoding,
+    ...rest
+  };
+  if (width !== void 0)
+    imgProps.width = String(width);
+  if (height !== void 0)
+    imgProps.height = String(height);
+  if (sizes)
+    imgProps.sizes = sizes;
+  if (fetchpriority)
+    imgProps.fetchpriority = fetchpriority;
+  if (srcSet)
+    imgProps.srcset = srcSet;
+  const placeholderStyle = buildPlaceholderStyle({ ...props, placeholder, blurDataURL }), mergedStyle = {
+    ...typeof style === "object" && style !== null ? style : {},
+    ...placeholderStyle ?? {},
+    ...shouldOptimize ? { "object-fit": resolved.fit } : {}
+  };
+  if (Object.keys(mergedStyle).length > 0)
+    imgProps.style = mergedStyle;
+  return imgProps;
+}
+export function Image(props) {
+  const resolved = resolveImageConfig(props), requestedFormats = props.formats ?? resolved.formats, primaryFormat = props.format ?? requestedFormats[0];
+  if (props.optimize === !1 || !props.width || requestedFormats.length <= 1)
+    return { type: "img", props: getImageProps({ ...props, format: primaryFormat }) };
+  const loader = resolved.loader ?? defaultImageLoader;
+  return {
+    type: "picture",
+    props: {
+      children: [
+        ...requestedFormats.slice(0, -1).map((candidateFormat) => ({
+          type: "source",
+          props: {
+            type: `image/${candidateFormat}`,
+            srcset: buildImageSrcSet(props.src, props.width, resolved.quality, loader, candidateFormat, resolved.widths),
+            sizes: props.sizes
+          }
+        })),
+        { type: "img", props: getImageProps({ ...props, format: primaryFormat }) }
+      ]
+    }
+  };
+}

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

@@ -0,0 +1,17 @@
+export { Suspense } from "./suspense.js";
+export { render, hydrate } from "./client.js";
+export { enterHydration, exitHydration, isHydrating, getHydrationMismatches, getHydrationDiagnostics, resetHydrationDiagnostics, } from "./hydration.js";
+export { renderToString, ssrJsx, ssrJsxs } from "./server.js";
+export { renderToStream, StreamSuspense, streamJsx, streamJsxs } from "./stream.js";
+export { EVENT_REPLAY_SCRIPT, replayEvents, stopEventCapture } from "./event-replay.js";
+export { Link } from "./link.js";
+export { Head } from "./head.js";
+export { navigate, onNavigate, beforeNavigate, getCurrentPath, getRouterNavigationDiagnostics, prefetch, initRouter, setLoadingElement, } from "./router.js";
+export { RUNTIME_DEVTOOLS_SCHEMA_VERSION, createRuntimeDevtoolsSnapshot, renderRuntimeDevtoolsHTML, renderRuntimeDevtoolsOverlay, type RuntimeDevtoolsOptions, type RuntimeDevtoolsRouteEntry, type RuntimeDevtoolsRouteSummary, type RuntimeDevtoolsSnapshot, type RuntimeDevtoolsSummary, type RuntimeDevtoolsTopNode, } from "./devtools.js";
+export { useFormAction, type FormActionResult, type FormState, type FormSubmitOptions } from "./form.js";
+export { Image, getImageProps, buildImageSrcSet, getImageCandidateWidths, isAllowedRemoteImage, defaultImageLoader, type ImageProps, type ImageLoader, type ImageLoaderParams, type ImageRuntimeConfig, type ImageRemotePattern, type ImageFormat, } from "./image.js";
+export { typedLink, typedNavigate, typedPrefetch, buildSearchParams, buildTypedPath, createTypedRoute, extractRouteParamKeys, } from "./typed-routes.js";
+export { defineForm, validateForm, validateAction, toFieldErrors, fieldAttrs, type FormField, type FormSchema, type ValidationResult, type ActionValidationResult, type ValidationError, } from "./validated-form.js";
+export { island, isIsland } from "./island.js";
+export { hydrateIslands, registerIsland } from "./island-hydrator.js";
+export { createEventSource, type EventSourceSignal } from "./event-source.js";

package/dist-pkg/runtime/index.js

@@ -0,0 +1,59 @@
+export { Suspense } from "./suspense.js";
+export { render, hydrate } from "./client.js";
+export {
+  enterHydration,
+  exitHydration,
+  isHydrating,
+  getHydrationMismatches,
+  getHydrationDiagnostics,
+  resetHydrationDiagnostics
+} from "./hydration.js";
+export { renderToString, ssrJsx, ssrJsxs } from "./server.js";
+export { renderToStream, StreamSuspense, streamJsx, streamJsxs } from "./stream.js";
+export { EVENT_REPLAY_SCRIPT, replayEvents, stopEventCapture } from "./event-replay.js";
+export { Link } from "./link.js";
+export { Head } from "./head.js";
+export {
+  navigate,
+  onNavigate,
+  beforeNavigate,
+  getCurrentPath,
+  getRouterNavigationDiagnostics,
+  prefetch,
+  initRouter,
+  setLoadingElement
+} from "./router.js";
+export {
+  RUNTIME_DEVTOOLS_SCHEMA_VERSION,
+  createRuntimeDevtoolsSnapshot,
+  renderRuntimeDevtoolsHTML,
+  renderRuntimeDevtoolsOverlay
+} from "./devtools.js";
+export { useFormAction } from "./form.js";
+export {
+  Image,
+  getImageProps,
+  buildImageSrcSet,
+  getImageCandidateWidths,
+  isAllowedRemoteImage,
+  defaultImageLoader
+} from "./image.js";
+export {
+  typedLink,
+  typedNavigate,
+  typedPrefetch,
+  buildSearchParams,
+  buildTypedPath,
+  createTypedRoute,
+  extractRouteParamKeys
+} from "./typed-routes.js";
+export {
+  defineForm,
+  validateForm,
+  validateAction,
+  toFieldErrors,
+  fieldAttrs
+} from "./validated-form.js";
+export { island, isIsland } from "./island.js";
+export { hydrateIslands, registerIsland } from "./island-hydrator.js";
+export { createEventSource } from "./event-source.js";

package/dist-pkg/runtime/island-hydrator.d.ts

@@ -0,0 +1,12 @@
+type IslandLoader = () => Promise<{
+    default: (props: Record<string, unknown>) => unknown;
+}>;
+/** Register an island component loader by name. */
+export declare function registerIsland(name: string, loader: IslandLoader): void;
+/**
+ * Hydrate all island components on the page.
+ * Finds all elements with data-island attribute and hydrates each independently.
+ * Lazy islands use IntersectionObserver to defer until visible.
+ */
+export declare function hydrateIslands(): void;
+export {};

package/dist-pkg/runtime/island-hydrator.js

@@ -0,0 +1,74 @@
+import { enterHydration, exitHydration } from "./hydration.js";
+import { replayEvents } from "./event-replay.js";
+const islandRegistry = new Map, hydrationStarted = new WeakSet;
+export function registerIsland(name, loader) {
+  islandRegistry.set(name, loader);
+}
+function parseIslandProps(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+      return parsed;
+    console.warn(`[gorsee] Island props payload must decode to an object: ${raw}`);
+    return {};
+  } catch {
+    console.warn(`[gorsee] Failed to parse island props: ${raw}`);
+    return {};
+  }
+}
+async function hydrateOne(el) {
+  const name = el.getAttribute("data-island");
+  if (!name)
+    return;
+  const loader = islandRegistry.get(name);
+  if (!loader) {
+    console.warn(`[gorsee] Island "${name}" not found in registry`);
+    return;
+  }
+  if (hydrationStarted.has(el))
+    return;
+  hydrationStarted.add(el);
+  let enteredHydration = !1;
+  try {
+    const component = (await loader()).default;
+    if (typeof component !== "function") {
+      hydrationStarted.delete(el);
+      console.warn(`[gorsee] Island "${name}" loader did not return a default component`);
+      return;
+    }
+    const rawProps = el.getAttribute("data-props") ?? "{}", props = parseIslandProps(rawProps);
+    enterHydration(el);
+    enteredHydration = !0;
+    component(props);
+    exitHydration();
+    enteredHydration = !1;
+    replayEvents(el);
+  } catch {
+    if (enteredHydration)
+      exitHydration();
+    hydrationStarted.delete(el);
+    console.warn(`[gorsee] Island "${name}" hydration failed`);
+  }
+}
+export function hydrateIslands() {
+  const islands = document.querySelectorAll("[data-island]");
+  for (let i = 0;i < islands.length; i++) {
+    const el = islands[i];
+    if (el.hasAttribute("data-island-lazy") && typeof IntersectionObserver < "u")
+      observeLazy(el);
+    else
+      hydrateOne(el);
+  }
+}
+function observeLazy(el) {
+  let hydrated = !1;
+  const observer = new IntersectionObserver((entries) => {
+    for (const entry of entries)
+      if (!hydrated && entry.isIntersecting) {
+        hydrated = !0;
+        observer.unobserve(el);
+        hydrateOne(el);
+      }
+  }, { rootMargin: "200px" });
+  observer.observe(el);
+}

package/dist-pkg/runtime/island.d.ts

@@ -0,0 +1,19 @@
+import type { GorseeRenderable } from "./renderable.js";
+export interface IslandOptions {
+    lazy?: boolean;
+}
+export declare const ISLAND_MARKER: unique symbol;
+interface IslandWrapper<P extends Record<string, unknown>> {
+    (props: P): GorseeRenderable;
+    [ISLAND_MARKER]: true;
+    componentName: string;
+    originalComponent: (props: P) => GorseeRenderable;
+    options: IslandOptions;
+}
+/**
+ * Wrap a component as an island -- only this component gets hydrated on the client.
+ * Static surrounding content stays as server-rendered HTML with zero JS.
+ */
+export declare function island<P extends Record<string, unknown>>(component: (props: P) => GorseeRenderable, options?: IslandOptions): IslandWrapper<P>;
+export declare function isIsland(fn: unknown): fn is IslandWrapper<Record<string, unknown>>;
+export {};

package/dist-pkg/runtime/island.js

@@ -0,0 +1,36 @@
+export const ISLAND_MARKER = Symbol("gorsee-island");
+function escapePropsForAttr(json) {
+  return json.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export function island(component, options = {}) {
+  const name = component.name || "Anonymous", wrapper = function islandWrapper(props) {
+    const propsWithoutChildren = extractSerializableProps(props), serialized = escapePropsForAttr(JSON.stringify(propsWithoutChildren)), attrs = {
+      "data-island": name,
+      "data-props": serialized,
+      children: component(props)
+    };
+    if (options.lazy)
+      attrs["data-island-lazy"] = "true";
+    return { type: "div", props: attrs };
+  };
+  wrapper[ISLAND_MARKER] = !0;
+  wrapper.componentName = name;
+  wrapper.originalComponent = component;
+  wrapper.options = options;
+  return wrapper;
+}
+function extractSerializableProps(props) {
+  const result = {};
+  for (const key in props) {
+    if (key === "children")
+      continue;
+    const val = props[key];
+    if (typeof val === "function" || typeof val === "symbol")
+      continue;
+    result[key] = val;
+  }
+  return result;
+}
+export function isIsland(fn) {
+  return typeof fn === "function" && ISLAND_MARKER in fn;
+}

package/dist-pkg/runtime/jsx-runtime.d.ts

@@ -0,0 +1,12 @@
+import type { GorseeRenderable } from "./renderable.js";
+export type GorseeNode = Node | string | number | boolean | null | undefined | GorseeNode[];
+export type Component = (props: Record<string, unknown>) => GorseeRenderable;
+export declare const Fragment: unique symbol;
+export interface JSXElement {
+    type: string | Component | symbol;
+    props: Record<string, unknown>;
+    children: unknown[];
+}
+export declare function jsx(type: string | Component | symbol, props: Record<string, unknown> | null): Node | DocumentFragment;
+export declare const jsxs: typeof jsx;
+export declare const jsxDEV: typeof jsx;

package/dist-pkg/runtime/jsx-runtime.js

@@ -0,0 +1,176 @@
+import { createEffect } from "../reactive/effect.js";
+import { isHydrating, claimElement, claimText, pushCursor, popCursor } from "./hydration.js";
+import { isRenderableThunk, isSignal } from "./html-escape.js";
+export const Fragment = Symbol("Fragment");
+function isVNodeLike(value) {
+  return typeof value === "object" && value !== null && "type" in value && "props" in value;
+}
+function renderVNodeLike(vnode) {
+  return jsx(vnode.type, vnode.props);
+}
+function createTextNode(value) {
+  return document.createTextNode(String(value ?? ""));
+}
+function bindProperty(el, key, value) {
+  if (key === "children" || key === "ref")
+    return;
+  if (key.startsWith("on:")) {
+    el.addEventListener(key.slice(3), value);
+    return;
+  }
+  if (key === "className" || key === "class") {
+    if (isSignal(value))
+      createEffect(() => {
+        el.className = String(value());
+      });
+    else if (!isHydrating())
+      el.className = String(value ?? "");
+    return;
+  }
+  if (key === "style" && typeof value === "object" && value !== null) {
+    const styles = value;
+    for (const [prop, val] of Object.entries(styles))
+      if (isSignal(val)) {
+        const p = prop;
+        createEffect(() => {
+          el.style.setProperty(p, String(val()));
+        });
+      } else if (!isHydrating())
+        el.style.setProperty(prop, String(val));
+    return;
+  }
+  if (isSignal(value))
+    createEffect(() => {
+      el.setAttribute(key, String(value()));
+    });
+  else if (!isHydrating()) {
+    if (typeof value === "boolean")
+      if (value)
+        el.setAttribute(key, "");
+      else
+        el.removeAttribute(key);
+    else if (value != null)
+      el.setAttribute(key, String(value));
+  }
+}
+function hydrateChild(parent, child) {
+  if (child == null || typeof child === "boolean")
+    return;
+  if (Array.isArray(child)) {
+    for (const c of child)
+      hydrateChild(parent, c);
+    return;
+  }
+  if (isVNodeLike(child)) {
+    renderVNodeLike(child);
+    return;
+  }
+  if (typeof child === "function" && isSignal(child)) {
+    const textNode = claimText(String(child() ?? "")) ?? createTextNode(child());
+    if (!textNode.parentNode)
+      parent.appendChild(textNode);
+    createEffect(() => {
+      textNode.textContent = String(child() ?? "");
+    });
+    return;
+  }
+  if (isRenderableThunk(child)) {
+    hydrateChild(parent, child());
+    return;
+  }
+  if (typeof child === "object" && child instanceof Node)
+    return;
+  const textNode = claimText(String(child ?? "")) ?? createTextNode(child);
+  if (!textNode.parentNode)
+    parent.appendChild(textNode);
+}
+function insertChild(parent, child) {
+  if (child == null || typeof child === "boolean")
+    return;
+  if (Array.isArray(child)) {
+    for (const c of child)
+      insertChild(parent, c);
+    return;
+  }
+  if (isVNodeLike(child)) {
+    parent.appendChild(renderVNodeLike(child));
+    return;
+  }
+  if (child instanceof Node) {
+    parent.appendChild(child);
+    return;
+  }
+  if (isSignal(child)) {
+    const textNode = createTextNode(child());
+    parent.appendChild(textNode);
+    createEffect(() => {
+      textNode.textContent = String(child() ?? "");
+    });
+    return;
+  }
+  if (isRenderableThunk(child)) {
+    insertChild(parent, child());
+    return;
+  }
+  parent.appendChild(createTextNode(child));
+}
+export function jsx(type, props) {
+  const allProps = props ?? {}, children = allProps.children, hydrating = isHydrating();
+  if (typeof type === "symbol") {
+    if (hydrating) {
+      if (children != null)
+        hydrateChild(document.createDocumentFragment(), children);
+      return document.createDocumentFragment();
+    }
+    const frag = document.createDocumentFragment();
+    if (children != null)
+      insertChild(frag, children);
+    return frag;
+  }
+  if (typeof type === "function") {
+    const result = type(allProps);
+    if (result instanceof Node)
+      return result;
+    if (isVNodeLike(result))
+      return renderVNodeLike(result);
+    if (isRenderableThunk(result)) {
+      const resolved = result();
+      if (hydrating) {
+        hydrateChild(document.createDocumentFragment(), resolved);
+        return document.createDocumentFragment();
+      }
+      const wrapper = document.createDocumentFragment();
+      insertChild(wrapper, resolved);
+      return wrapper;
+    }
+    if (hydrating) {
+      hydrateChild(document.createDocumentFragment(), result);
+      return document.createDocumentFragment();
+    }
+    const wrapper = document.createDocumentFragment();
+    insertChild(wrapper, result);
+    return wrapper;
+  }
+  if (hydrating) {
+    const el = claimElement(type);
+    if (el) {
+      for (const [key, value] of Object.entries(allProps))
+        if (key !== "children")
+          bindProperty(el, key, value);
+      if (children != null) {
+        pushCursor(el);
+        hydrateChild(el, children);
+        popCursor();
+      }
+      return el;
+    }
+  }
+  const el = document.createElement(type);
+  for (const [key, value] of Object.entries(allProps))
+    if (key !== "children")
+      bindProperty(el, key, value);
+  if (children != null)
+    insertChild(el, children);
+  return el;
+}
+export const jsxs = jsx, jsxDEV = jsx;

package/dist-pkg/runtime/link.d.ts

@@ -0,0 +1,16 @@
+import { type TypedRouteDefinition, type TypedRouteOptions, type TypedRouteParams } from "./typed-routes.js";
+import type { GorseeRenderable } from "./renderable.js";
+export interface LinkProps {
+    href: string | TypedRouteDefinition;
+    params?: TypedRouteParams;
+    search?: TypedRouteOptions["search"];
+    hash?: string;
+    children?: unknown;
+    class?: string;
+    className?: string;
+    prefetch?: boolean | "hover" | "viewport";
+    replace?: boolean;
+    target?: string;
+    [key: string]: unknown;
+}
+export declare function Link(props: LinkProps): GorseeRenderable;

package/dist-pkg/runtime/link.js

@@ -0,0 +1,47 @@
+import { navigate, prefetch } from "./router.js";
+import { resolveTypedRouteTarget } from "./typed-routes.js";
+function composeEventHandlers(first, second) {
+  if (!first)
+    return second;
+  if (!second)
+    return first;
+  return (event) => {
+    first(event);
+    second(event);
+  };
+}
+export function Link(props) {
+  const { href, params, search, hash, prefetch: prefetchMode, replace, children, ...rest } = props, resolvedHref = resolveTypedRouteTarget(href, { params, search, hash }), restProps = { ...rest }, onClick = restProps["on:click"], onMouseOver = restProps["on:mouseover"], onFocus = restProps["on:focus"];
+  delete restProps["on:click"];
+  delete restProps["on:mouseover"];
+  delete restProps["on:focus"];
+  delete restProps["data-g-prefetch"];
+  if (prefetchMode === !0 && typeof window < "u")
+    prefetch(resolvedHref);
+  const hoverPrefetchHandler = prefetchMode === "hover" ? () => prefetch(resolvedHref) : void 0;
+  return {
+    type: "a",
+    props: {
+      href: resolvedHref,
+      ...restProps,
+      ...prefetchMode === "viewport" ? { "data-g-prefetch": "viewport" } : {},
+      "on:click": (e) => {
+        if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0)
+          return;
+        const target = e.currentTarget?.target;
+        if (target && target !== "_self")
+          return;
+        e.preventDefault();
+        if (replace)
+          history.replaceState({ gorsee: !0 }, "", resolvedHref);
+        navigate(resolvedHref, !replace);
+        onClick?.(e);
+      },
+      ...prefetchMode === "hover" ? {
+        "on:mouseover": composeEventHandlers(onMouseOver, hoverPrefetchHandler),
+        "on:focus": composeEventHandlers(onFocus, hoverPrefetchHandler)
+      } : {},
+      children
+    }
+  };
+}

package/dist-pkg/runtime/project.d.ts

@@ -0,0 +1,37 @@
+export interface ProjectPathOverrides extends Partial<ProjectPaths> {
+}
+export interface RuntimeOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    pathOverrides?: ProjectPathOverrides;
+}
+export interface ProjectPaths {
+    cwd: string;
+    routesDir: string;
+    publicDir: string;
+    distDir: string;
+    clientDir: string;
+    serverDir: string;
+    gorseeDir: string;
+    sharedDir: string;
+    middlewareDir: string;
+    migrationsDir: string;
+    docsDir: string;
+    dataFile: string;
+    appConfigFile: string;
+}
+export interface ProjectContext {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    paths: ProjectPaths;
+}
+export interface RuntimeEnvConfig {
+    port: number;
+    logLevel: "info" | "debug";
+    rateLimit: number;
+    rateWindow: string;
+    isProduction: boolean;
+}
+export declare function resolveProjectPaths(cwd: string, overrides?: ProjectPathOverrides): ProjectPaths;
+export declare function createProjectContext(options?: RuntimeOptions): ProjectContext;
+export declare function resolveRuntimeEnv(env: NodeJS.ProcessEnv): RuntimeEnvConfig;