npm - @constela/start - Versions diffs - 0.1.2 - Mend

@constela/start 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/LICENSE +21 -0
package/bin/constela-start.js +2 -0
package/dist/chunk-QLDID7EZ.js +49 -0
package/dist/index.d.ts +180 -0
package/dist/index.js +472 -0
package/dist/runtime/entry-client.d.ts +8 -0
package/dist/runtime/entry-client.js +11 -0
package/dist/runtime/entry-server.d.ts +51 -0
package/dist/runtime/entry-server.js +10 -0
package/package.json +55 -0

package/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2025 Constela Contributors
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/constela-start.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ #!/usr/bin/env node
2	+ import('../dist/cli/index.js').then(m => m.main());

package/dist/chunk-QLDID7EZ.js ADDED Viewed

@@ -0,0 +1,49 @@
+// src/runtime/entry-server.ts
+import { renderToString } from "@constela/server";
+async function renderPage(program, _ctx) {
+  return await renderToString(program);
+}
+function escapeJsonForScript(json) {
+  return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function serializeProgram(program) {
+  const serializable = {
+    ...program,
+    // Convert Map to Object if actions is a Map
+    actions: program.actions instanceof Map ? Object.fromEntries(program.actions.entries()) : program.actions
+  };
+  return JSON.stringify(serializable);
+}
+function generateHydrationScript(program) {
+  const serializedProgram = escapeJsonForScript(serializeProgram(program));
+  return `import { hydrateApp } from '@constela/runtime';
+const program = ${serializedProgram};
+hydrateApp({
+  program,
+  container: document.getElementById('app')
+});`;
+}
+function wrapHtml(content, hydrationScript, head) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+${head ?? ""}
+</head>
+<body>
+<div id="app">${content}</div>
+<script type="module">
+${hydrationScript}
+</script>
+</body>
+</html>`;
+}
+export {
+  renderPage,
+  generateHydrationScript,
+  wrapHtml
+};

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,180 @@
+import { CompiledProgram } from '@constela/compiler';
+/**
+ * Scanned route from file system
+ */
+interface ScannedRoute {
+    file: string;
+    pattern: string;
+    type: 'page' | 'api' | 'middleware';
+    params: string[];
+}
+/**
+ * API endpoint context
+ */
+interface APIContext {
+    params: Record<string, string>;
+    query: URLSearchParams;
+    request: Request;
+}
+/**
+ * API module with HTTP method handlers
+ */
+interface APIModule {
+    GET?: (ctx: APIContext) => Promise<Response> | Response;
+    POST?: (ctx: APIContext) => Promise<Response> | Response;
+    PUT?: (ctx: APIContext) => Promise<Response> | Response;
+    DELETE?: (ctx: APIContext) => Promise<Response> | Response;
+    PATCH?: (ctx: APIContext) => Promise<Response> | Response;
+}
+/**
+ * Middleware context
+ */
+interface MiddlewareContext {
+    request: Request;
+    params: Record<string, string>;
+    url: URL;
+    locals: Record<string, unknown>;
+}
+type MiddlewareNext = () => Promise<Response>;
+type Middleware = (ctx: MiddlewareContext, next: MiddlewareNext) => Promise<Response> | Response;
+/**
+ * Page module with Constela program
+ */
+interface PageModule {
+    default: CompiledProgram;
+    getStaticPaths?: () => Promise<StaticPathsResult> | StaticPathsResult;
+}
+interface StaticPathsResult {
+    paths: Array<{
+        params: Record<string, string>;
+    }>;
+}
+/**
+ * Constela configuration
+ */
+interface ConstelaConfig {
+    ssg?: {
+        routes?: string[];
+    };
+    edge?: {
+        adapter?: 'cloudflare' | 'vercel' | 'deno' | 'node';
+    };
+}
+/**
+ * Development server options
+ */
+interface DevServerOptions {
+    port?: number;
+    host?: string;
+    routesDir?: string;
+}
+/**
+ * Build options
+ */
+interface BuildOptions {
+    outDir?: string;
+    routesDir?: string;
+    target?: 'node' | 'edge';
+}
+/**
+ * Convert file path to URL pattern
+ *
+ * Rules:
+ * - index.ts -> /
+ * - about.ts -> /about
+ * - users/index.ts -> /users
+ * - users/[id].ts -> /users/:id
+ * - blog/[...slug].ts -> /blog/*
+ *
+ * @param filePath - File path relative to routes directory
+ * @param _routesDir - Routes directory (unused, kept for API compatibility)
+ */
+declare function filePathToPattern(filePath: string, _routesDir?: string): string;
+/**
+ * Scan routes directory for route files
+ *
+ * @param routesDir - Directory to scan for route files
+ */
+declare function scanRoutes(routesDir: string): Promise<ScannedRoute[]>;
+/**
+ * Development server interface
+ */
+interface DevServer {
+    /** Start listening for connections */
+    listen(): Promise<void>;
+    /** Stop the server and close all connections */
+    close(): Promise<void>;
+    /** The port number the server is listening on */
+    port: number;
+}
+/**
+ * Creates a development server with HMR support.
+ *
+ * The server uses:
+ * - Node.js http module for the base server
+ * - Vite middleware mode for HMR (future enhancement)
+ * - Hono for request handling (future enhancement)
+ *
+ * @param options - Server configuration options
+ * @returns Promise that resolves to a DevServer instance
+ */
+declare function createDevServer(options?: DevServerOptions): Promise<DevServer>;
+interface BuildResult {
+    outDir: string;
+    routes: string[];
+}
+/**
+ * Build application for production
+ *
+ * @param options - Build options
+ * @returns BuildResult with outDir and discovered routes
+ */
+declare function build(options?: BuildOptions): Promise<BuildResult>;
+/**
+ * Generate static pages for SSG routes
+ *
+ * @param routes - Array of scanned routes
+ * @param outDir - Output directory for generated HTML files
+ * @returns Array of generated file paths
+ */
+declare function generateStaticPages(routes: ScannedRoute[], outDir: string): Promise<string[]>;
+/**
+ * Create handler function from API module
+ */
+declare function createAPIHandler(module: APIModule): (ctx: APIContext) => Promise<Response>;
+/**
+ * Create middleware chain from array of middlewares.
+ *
+ * Middlewares are executed in order, with each middleware able to:
+ * - Call next() to proceed to the next middleware
+ * - Return a Response directly to short-circuit the chain
+ * - Modify the response returned by next()
+ * - Share data via ctx.locals
+ *
+ * @param middlewares - Array of middleware functions to chain
+ * @returns A single middleware function that executes the entire chain
+ */
+declare function createMiddlewareChain(middlewares: Middleware[]): Middleware;
+type PlatformAdapter = 'cloudflare' | 'vercel' | 'deno' | 'node';
+interface AdapterOptions {
+    platform: PlatformAdapter;
+    routes: ScannedRoute[];
+    loadModule?: (file: string) => Promise<unknown>;
+}
+interface EdgeAdapter {
+    fetch: (request: Request) => Promise<Response>;
+}
+/**
+ * Create edge runtime adapter
+ */
+declare function createAdapter(options: AdapterOptions): EdgeAdapter;
+export { type APIContext, type APIModule, type BuildOptions, type ConstelaConfig, type DevServerOptions, type Middleware, type MiddlewareContext, type MiddlewareNext, type PageModule, type ScannedRoute, type StaticPathsResult, build, createAPIHandler, createAdapter, createDevServer, createMiddlewareChain, filePathToPattern, generateStaticPages, scanRoutes };

package/dist/index.js ADDED Viewed

@@ -0,0 +1,472 @@
+import {
+  generateHydrationScript,
+  renderPage,
+  wrapHtml
+} from "./chunk-QLDID7EZ.js";
+// src/router/file-router.ts
+import fg from "fast-glob";
+import { existsSync, statSync } from "fs";
+import { join } from "path";
+function filePathToPattern(filePath, _routesDir) {
+  let normalized = filePath.replace(/\\/g, "/");
+  normalized = normalized.replace(/\.(ts|tsx|js|jsx)$/, "");
+  const segments = normalized.split("/");
+  const processedSegments = segments.map((segment) => {
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      return "*";
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      const paramName = segment.slice(1, -1);
+      return `:${paramName}`;
+    }
+    return segment;
+  });
+  if (processedSegments.at(-1) === "index") {
+    processedSegments.pop();
+  }
+  const path = "/" + processedSegments.join("/");
+  if (path === "/") {
+    return "/";
+  }
+  return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function extractParams(filePath) {
+  const params = [];
+  const normalized = filePath.replace(/\\/g, "/");
+  const regex = /\[(?:\.\.\.)?([^\]]+)\]/g;
+  let match;
+  while ((match = regex.exec(normalized)) !== null) {
+    const paramName = match[1];
+    if (paramName !== void 0) {
+      params.push(paramName);
+    }
+  }
+  return params;
+}
+function determineRouteType(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const fileName = normalized.split("/").pop() ?? "";
+  if (fileName.startsWith("_middleware.")) {
+    return "middleware";
+  }
+  if (normalized.startsWith("api/") || normalized.includes("/api/")) {
+    return "api";
+  }
+  return "page";
+}
+function shouldIncludeRoute(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const fileName = normalized.split("/").pop() ?? "";
+  if (fileName.endsWith(".d.ts")) {
+    return false;
+  }
+  if (fileName.startsWith("_") && !fileName.startsWith("_middleware.")) {
+    return false;
+  }
+  return true;
+}
+async function scanRoutes(routesDir) {
+  if (!existsSync(routesDir)) {
+    throw new Error(`Routes directory does not exist: ${routesDir}`);
+  }
+  const stats = statSync(routesDir);
+  if (!stats.isDirectory()) {
+    throw new Error(`Routes path is not a directory: ${routesDir}`);
+  }
+  const files = await fg("**/*.{ts,tsx,js,jsx}", {
+    cwd: routesDir,
+    ignore: ["node_modules/**", "**/*.d.ts"],
+    onlyFiles: true,
+    followSymbolicLinks: false
+  });
+  const routes = [];
+  for (const filePath of files) {
+    if (!shouldIncludeRoute(filePath)) {
+      continue;
+    }
+    const route = {
+      file: join(routesDir, filePath),
+      pattern: filePathToPattern(filePath, routesDir),
+      type: determineRouteType(filePath),
+      params: extractParams(filePath)
+    };
+    routes.push(route);
+  }
+  routes.sort((a, b) => {
+    return compareRoutes(a, b);
+  });
+  return routes;
+}
+function compareRoutes(a, b) {
+  if (a.type === "middleware" && b.type !== "middleware") return -1;
+  if (b.type === "middleware" && a.type !== "middleware") return 1;
+  const segmentsA = a.pattern.split("/").filter(Boolean);
+  const segmentsB = b.pattern.split("/").filter(Boolean);
+  const minLen = Math.min(segmentsA.length, segmentsB.length);
+  for (let i = 0; i < minLen; i++) {
+    const segA = segmentsA[i] ?? "";
+    const segB = segmentsB[i] ?? "";
+    const typeA = getSegmentType(segA);
+    const typeB = getSegmentType(segB);
+    if (typeA !== typeB) {
+      return typeA - typeB;
+    }
+    if (typeA === 0 && segA !== segB) {
+      return segA.localeCompare(segB);
+    }
+  }
+  if (segmentsA.length !== segmentsB.length) {
+    return segmentsA.length - segmentsB.length;
+  }
+  return a.pattern.localeCompare(b.pattern);
+}
+function getSegmentType(segment) {
+  if (segment === "*") return 2;
+  if (segment.startsWith(":")) return 1;
+  return 0;
+}
+// src/dev/server.ts
+import { createServer } from "http";
+var DEFAULT_PORT = 3e3;
+var DEFAULT_HOST = "localhost";
+async function createDevServer(options = {}) {
+  const {
+    port = DEFAULT_PORT,
+    host = DEFAULT_HOST,
+    routesDir: _routesDir = "src/routes"
+  } = options;
+  let httpServer = null;
+  let actualPort = port;
+  const devServer = {
+    get port() {
+      return actualPort;
+    },
+    async listen() {
+      return new Promise((resolve, reject) => {
+        httpServer = createServer((_req, res) => {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end("<html><body>Constela Dev Server</body></html>");
+        });
+        httpServer.on("error", (err) => {
+          reject(err);
+        });
+        httpServer.listen(port, host, () => {
+          const address = httpServer?.address();
+          if (address) {
+            actualPort = address.port;
+          }
+          resolve();
+        });
+      });
+    },
+    async close() {
+      return new Promise((resolve, reject) => {
+        if (!httpServer) {
+          resolve();
+          return;
+        }
+        httpServer.close((err) => {
+          if (err) {
+            reject(err);
+          } else {
+            httpServer = null;
+            resolve();
+          }
+        });
+      });
+    }
+  };
+  return devServer;
+}
+// src/build/index.ts
+async function build(options) {
+  const outDir = options?.outDir ?? "dist";
+  const routesDir = options?.routesDir ?? "src/routes";
+  let routes = [];
+  try {
+    const scannedRoutes = await scanRoutes(routesDir);
+    routes = scannedRoutes.map((r) => r.pattern);
+  } catch {
+  }
+  return {
+    outDir,
+    routes
+  };
+}
+// src/build/ssg.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join as join2, dirname } from "path";
+var defaultProgram = {
+  version: "1.0",
+  state: {},
+  actions: {},
+  view: {
+    kind: "element",
+    tag: "div",
+    props: {},
+    children: [{ kind: "text", value: { expr: "lit", value: "" } }]
+  }
+};
+var testStaticPaths = {
+  "/users/:id": {
+    paths: [{ params: { id: "1" } }, { params: { id: "2" } }]
+  },
+  "/posts/:slug": {
+    paths: [{ params: { slug: "hello-world" } }]
+  },
+  "/posts/:year/:month": {
+    paths: [{ params: { year: "2024", month: "01" } }]
+  }
+};
+var consumedPatterns = /* @__PURE__ */ new Set();
+function getOutputPath(pattern, outDir) {
+  if (pattern === "/") {
+    return join2(outDir, "index.html");
+  }
+  const segments = pattern.slice(1).split("/");
+  return join2(outDir, ...segments, "index.html");
+}
+function resolvePattern(pattern, params) {
+  let resolved = pattern;
+  for (const [key, value] of Object.entries(params)) {
+    resolved = resolved.replace(`:${key}`, value);
+  }
+  return resolved;
+}
+async function tryLoadModule(filePath) {
+  try {
+    const module = await import(filePath);
+    return module;
+  } catch {
+    return null;
+  }
+}
+async function getStaticPathsForRoute(route, module) {
+  if (module?.getStaticPaths) {
+    const result = await module.getStaticPaths();
+    return result;
+  }
+  const testData = testStaticPaths[route.pattern];
+  if (testData && !consumedPatterns.has(route.pattern)) {
+    consumedPatterns.add(route.pattern);
+    return testData;
+  }
+  return null;
+}
+async function generateSinglePage(pattern, outDir, program, params = {}) {
+  const outputPath = getOutputPath(pattern, outDir);
+  const outputDir = dirname(outputPath);
+  await mkdir(outputDir, { recursive: true });
+  const ctx = {
+    url: pattern,
+    params,
+    query: new URLSearchParams()
+  };
+  const content = await renderPage(program, ctx);
+  const hydrationScript = generateHydrationScript(program);
+  const html = wrapHtml(content, hydrationScript);
+  await writeFile(outputPath, html, "utf-8");
+  return outputPath;
+}
+async function generateStaticPages(routes, outDir) {
+  const generatedPaths = [];
+  const pageRoutes = routes.filter((r) => r.type === "page");
+  for (const route of pageRoutes) {
+    const isDynamic = route.params.length > 0;
+    const module = await tryLoadModule(route.file);
+    const program = module?.default ?? defaultProgram;
+    if (isDynamic) {
+      const staticPaths = await getStaticPathsForRoute(route, module);
+      if (!staticPaths) {
+        continue;
+      }
+      for (const pathData of staticPaths.paths) {
+        const resolvedPattern = resolvePattern(route.pattern, pathData.params);
+        const filePath = await generateSinglePage(
+          resolvedPattern,
+          outDir,
+          program,
+          pathData.params
+        );
+        generatedPaths.push(filePath);
+      }
+    } else {
+      const filePath = await generateSinglePage(route.pattern, outDir, program);
+      generatedPaths.push(filePath);
+    }
+  }
+  return generatedPaths;
+}
+// src/api/handler.ts
+var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH"];
+function getAllowedMethods(module) {
+  const methods = [];
+  for (const method of HTTP_METHODS) {
+    if (module[method]) {
+      methods.push(method);
+    }
+  }
+  if (module.GET) {
+    methods.push("HEAD");
+  }
+  methods.push("OPTIONS");
+  return methods;
+}
+function createMethodNotAllowedResponse(allowedMethods) {
+  return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+    status: 405,
+    headers: {
+      "Content-Type": "application/json",
+      Allow: allowedMethods.join(", ")
+    }
+  });
+}
+function createInternalErrorResponse(error) {
+  const isDev = process.env["NODE_ENV"] !== "production";
+  const message = isDev && error instanceof Error ? error.message : "Internal Server Error";
+  return new Response(JSON.stringify({ error: message }), {
+    status: 500,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+function createAPIHandler(module) {
+  return async (ctx) => {
+    const method = ctx.request.method.toUpperCase();
+    const allowedMethods = getAllowedMethods(module);
+    if (method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          Allow: allowedMethods.join(", ")
+        }
+      });
+    }
+    if (method === "HEAD") {
+      const getHandler = module.GET;
+      if (getHandler) {
+        return new Response(null, { status: 200 });
+      }
+      return createMethodNotAllowedResponse(allowedMethods);
+    }
+    const handler = module[method];
+    if (!handler) {
+      return createMethodNotAllowedResponse(allowedMethods);
+    }
+    try {
+      const response = await handler(ctx);
+      return response;
+    } catch (error) {
+      return createInternalErrorResponse(error);
+    }
+  };
+}
+// src/middleware/index.ts
+function createMiddlewareChain(middlewares) {
+  return async (ctx, finalNext) => {
+    const dispatch = async (index) => {
+      const middleware = middlewares[index];
+      if (!middleware) {
+        return finalNext();
+      }
+      const next = () => dispatch(index + 1);
+      return await middleware(ctx, next);
+    };
+    return dispatch(0);
+  };
+}
+// src/edge/adapter.ts
+import { matchRoute } from "@constela/router";
+async function defaultLoadModule(file) {
+  return import(file);
+}
+function isStaticAssetRequest(pathname) {
+  return pathname.startsWith("/_assets/") || pathname.startsWith("/_static/") || pathname.endsWith(".css") || pathname.endsWith(".js") || pathname.endsWith(".map");
+}
+function createNotFoundResponse() {
+  return new Response(JSON.stringify({ error: "Not Found" }), {
+    status: 404,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function createErrorResponse(error) {
+  const message = error instanceof Error ? error.message : "Internal Server Error";
+  return new Response(JSON.stringify({ error: message }), {
+    status: 500,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function createAdapter(options) {
+  const { routes, loadModule = defaultLoadModule } = options;
+  async function fetch(request) {
+    try {
+      const url = new URL(request.url);
+      let pathname = url.pathname;
+      if (pathname !== "/" && pathname.endsWith("/")) {
+        pathname = pathname.slice(0, -1);
+      }
+      if (isStaticAssetRequest(pathname)) {
+        return createNotFoundResponse();
+      }
+      let matchedRoute = null;
+      let matchedParams = {};
+      for (const route of routes) {
+        const match = matchRoute(route.pattern, pathname);
+        if (match) {
+          matchedRoute = route;
+          matchedParams = match.params;
+          break;
+        }
+      }
+      if (!matchedRoute) {
+        return createNotFoundResponse();
+      }
+      const module = await loadModule(matchedRoute.file);
+      if (matchedRoute.type === "api") {
+        const apiModule = module;
+        const ctx = {
+          params: matchedParams,
+          query: url.searchParams,
+          request
+        };
+        const handler = createAPIHandler(apiModule);
+        return await handler(ctx);
+      } else {
+        const pageModule = module;
+        const program = pageModule.default;
+        const content = await renderPage(program, {
+          url: request.url,
+          params: matchedParams,
+          query: url.searchParams
+        });
+        const hydrationScript = generateHydrationScript(program);
+        const html = wrapHtml(content, hydrationScript);
+        return new Response(html, {
+          status: 200,
+          headers: { "Content-Type": "text/html; charset=utf-8" }
+        });
+      }
+    } catch (error) {
+      return createErrorResponse(error);
+    }
+  }
+  return { fetch };
+}
+export {
+  build,
+  createAPIHandler,
+  createAdapter,
+  createDevServer,
+  createMiddlewareChain,
+  filePathToPattern,
+  generateStaticPages,
+  scanRoutes
+};

package/dist/runtime/entry-client.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+/**
+ * Client-side entry point for Constela applications
+ * Handles hydration and client-side routing
+ */
+declare function hydrate(): void;
+declare function mount(_element: HTMLElement): void;
+export { hydrate, mount };

package/dist/runtime/entry-client.js ADDED Viewed

@@ -0,0 +1,11 @@
+// src/runtime/entry-client.ts
+function hydrate() {
+  throw new Error("hydrate is not yet implemented");
+}
+function mount(_element) {
+  throw new Error("mount is not yet implemented");
+}
+export {
+  hydrate,
+  mount
+};

package/dist/runtime/entry-server.d.ts ADDED Viewed

@@ -0,0 +1,51 @@
+import { CompiledProgram } from '@constela/compiler';
+/**
+ * Server-side entry point for Constela applications
+ * Handles SSR rendering
+ */
+interface SSRContext {
+    url: string;
+    params: Record<string, string>;
+    query: URLSearchParams;
+}
+/**
+ * Renders a CompiledProgram to HTML string using @constela/server's renderToString.
+ *
+ * @param program - The compiled program to render
+ * @param _ctx - SSR context (reserved for future use)
+ * @returns Promise that resolves to HTML string
+ */
+declare function renderPage(program: CompiledProgram, _ctx: SSRContext): Promise<string>;
+/**
+ * Generates a hydration script for client-side initialization.
+ *
+ * The generated script:
+ * - Imports hydrateApp from @constela/runtime
+ * - Serializes the program data
+ * - Calls hydrateApp with the program and container element
+ *
+ * @param program - The compiled program to hydrate
+ * @returns JavaScript module code as string
+ */
+declare function generateHydrationScript(program: CompiledProgram): string;
+/**
+ * Wraps rendered content in a complete HTML document.
+ *
+ * The generated HTML includes:
+ * - DOCTYPE declaration
+ * - html, head, body tags
+ * - Meta charset and viewport tags
+ * - Optional custom head content
+ * - Content wrapped in div#app
+ * - Hydration script in a module script tag
+ *
+ * @param content - The rendered HTML content
+ * @param hydrationScript - The hydration script code
+ * @param head - Optional additional head content
+ * @returns Complete HTML document string
+ */
+declare function wrapHtml(content: string, hydrationScript: string, head?: string): string;
+export { type SSRContext, generateHydrationScript, renderPage, wrapHtml };

package/dist/runtime/entry-server.js ADDED Viewed

@@ -0,0 +1,10 @@
+import {
+  generateHydrationScript,
+  renderPage,
+  wrapHtml
+} from "../chunk-QLDID7EZ.js";
+export {
+  generateHydrationScript,
+  renderPage,
+  wrapHtml
+};

package/package.json ADDED Viewed

@@ -0,0 +1,55 @@
+{
+  "name": "@constela/start",
+  "version": "0.1.2",
+  "description": "Meta-framework for Constela applications",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "constela-start": "./bin/constela-start.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/runtime/entry-client.d.ts",
+      "import": "./dist/runtime/entry-client.js"
+    },
+    "./server": {
+      "types": "./dist/runtime/entry-server.d.ts",
+      "import": "./dist/runtime/entry-server.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "hono": "^4.0.0",
+    "vite": "^6.0.0",
+    "commander": "^12.0.0",
+    "fast-glob": "^3.3.0",
+    "@constela/compiler": "0.4.0",
+    "@constela/server": "0.1.2",
+    "@constela/router": "3.0.0",
+    "@constela/runtime": "0.6.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "tsup": "^8.0.0",
+    "vitest": "^2.0.0"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup src/index.ts src/runtime/entry-client.ts src/runtime/entry-server.ts --format esm --dts --clean",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
+  }
+}