@worktif/runtime 0.3.0-edge.0

package/out/dist/bin/templates/runtime-web/purenow-basic/src/pages/about-page.tsx

@@ -0,0 +1,65 @@
+/*
+ * Elastic License 2.0
+ * Copyright (C) 2025–present Raman Marozau, Work Target Insight Function. All rights reserved.
+ * Contact: raman@worktif.com
+ *
+ * This file is part of the Licensed Work: worktif.purenow.cdk <worktif_purenow_cdk>.
+ * Use of this software is governed by the Elastic License 2.0; see the LICENSE file
+ * or https://www.elastic.co/licensing/elastic-license for details.
+ *
+ * Re-licensing notice:
+ *   This file was previously distributed under the Business Source License 1.1 (BUSL-1.1).
+ *   As of 2025-09-22, it is re-licensed under Elastic License 2.0.
+ *
+ * SPDX-License-Identifier: Elastic-2.0
+ */
+
+import * as React from 'react';
+import { Link } from 'react-router';
+
+/**
+ * About page component demonstrating client-side navigation
+ */
+const AboutPage: React.FC = () => {
+  return (
+    <div style={{ padding: '2rem', fontFamily: 'system-ui, sans-serif' }}>
+      <h1>About This Project</h1>
+
+      <div style={{ marginTop: '2rem' }}>
+        <h2>What is Purenow?</h2>
+        <p>
+          Purenow is a serverless framework for building React applications with
+          server-side rendering (SSR) on AWS Lambda. It provides a seamless developer
+          experience for creating high-performance web applications that scale automatically.
+        </p>
+      </div>
+
+      <div style={{ marginTop: '2rem' }}>
+        <h2>Architecture</h2>
+        <ul>
+          <li><strong>AWS Lambda:</strong> Handles SSR requests with minimal cold start times</li>
+          <li><strong>CloudFront:</strong> Global CDN for fast content delivery</li>
+          <li><strong>S3:</strong> Static asset hosting with intelligent caching</li>
+          <li><strong>API Gateway:</strong> Routes requests to Lambda handlers</li>
+          <li><strong>DynamoDB:</strong> Optional SEO metadata storage</li>
+        </ul>
+      </div>
+
+      <div style={{ marginTop: '2rem' }}>
+        <h2>Getting Started</h2>
+        <p>
+          To learn more about Purenow and how to build your own serverless React applications,
+          visit the documentation or explore the source code.
+        </p>
+      </div>
+
+      <div style={{ marginTop: '2rem' }}>
+        <Link to="/" style={{ color: '#0066cc', textDecoration: 'none' }}>
+          ← Back to Home
+        </Link>
+      </div>
+    </div>
+  );
+};
+
+export default AboutPage;

package/out/dist/bin/templates/runtime-web/purenow-basic/src/pages/home-page.tsx

@@ -0,0 +1,55 @@
+/*
+ * Elastic License 2.0
+ * Copyright (C) 2025–present Raman Marozau, Work Target Insight Function. All rights reserved.
+ * Contact: raman@worktif.com
+ *
+ * This file is part of the Licensed Work: worktif.purenow.cdk <worktif_purenow_cdk>.
+ * Use of this software is governed by the Elastic License 2.0; see the LICENSE file
+ * or https://www.elastic.co/licensing/elastic-license for details.
+ *
+ * Re-licensing notice:
+ *   This file was previously distributed under the Business Source License 1.1 (BUSL-1.1).
+ *   As of 2025-09-22, it is re-licensed under Elastic License 2.0.
+ *
+ * SPDX-License-Identifier: Elastic-2.0
+ */
+
+import * as React from 'react';
+import { Link } from 'react-router';
+
+/**
+ * Home page component demonstrating Purenow SSR capabilities
+ */
+const HomePage: React.FC = () => {
+  return (
+    <div style={{ padding: '2rem', fontFamily: 'system-ui, sans-serif' }}>
+      <h1>Welcome to Purenow</h1>
+      <p>
+        This is a serverless React SSR application powered by AWS Lambda and CloudFront.
+      </p>
+
+      <div style={{ marginTop: '2rem' }}>
+        <h2>Features</h2>
+        <ul>
+          <li>Server-Side Rendering (SSR) on AWS Lambda</li>
+          <li>React Router v7 integration</li>
+          <li>CloudFront CDN distribution</li>
+          <li>S3 caching with ETag support</li>
+          <li>TypeScript support</li>
+        </ul>
+      </div>
+
+      <div style={{ marginTop: '2rem' }}>
+        <Link to="/about" style={{ color: '#0066cc', textDecoration: 'none' }}>
+          Learn more about this project →
+        </Link>
+      </div>
+
+      <footer style={{ marginTop: '4rem', color: '#666', fontSize: '0.875rem' }}>
+        <p>Built with Purenow &copy; 2025</p>
+      </footer>
+    </div>
+  );
+};
+
+export default HomePage;

package/out/dist/bin/templates/runtime-web/purenow-basic/src/pages/users-page.tsx

@@ -0,0 +1,66 @@
+/*
+ * Elastic License 2.0
+ * Copyright (C) 2025–present Raman Marozau, Work Target Insight Function. All rights reserved.
+ * Contact: raman@worktif.com
+ *
+ * This file is part of the Licensed Work: worktif.purenow.cdk <worktif_purenow_cdk>.
+ * Use of this software is governed by the Elastic License 2.0; see the LICENSE file
+ * or https://www.elastic.co/licensing/elastic-license for details.
+ *
+ * Re-licensing notice:
+ *   This file was previously distributed under the Business Source License 1.1 (BUSL-1.1).
+ *   As of 2025-09-22, it is re-licensed under Elastic License 2.0.
+ *
+ * SPDX-License-Identifier: Elastic-2.0
+ */
+
+import * as React from 'react';
+import { Link } from 'react-router';
+
+/**
+ * About page component demonstrating client-side navigation
+ */
+const UsersPage: React.FC = () => {
+  return (
+    <div style={{ padding: '2rem', fontFamily: 'system-ui, sans-serif' }}>
+      <h1>Users Page – Example</h1>
+
+      <div style={{ marginTop: '2rem' }}>
+        <h2>What is Purenow?</h2>
+        <p>
+          Purenow is a serverless framework for building React applications with
+          server-side rendering (SSR) on AWS Lambda. It provides a seamless developer
+          experience for creating high-performance web applications that scale automatically.
+        </p>
+      </div>
+
+      <div style={{ marginTop: '2rem' }}>
+        <p>Manage user accounts and profiles.</p>
+        <h2>Available Endpoints</h2>
+        <ul>
+          <li><strong>POST /api/users</strong> - Create a user</li>
+          <li><strong>GET /api/users/:id</strong> - Get a user</li>
+          <li><strong>PUT /api/users/:id</strong> - Update a user</li>
+          <li><strong>DELETE /api/users/:id</strong> - Delete a user</li>
+        </ul>
+      </div>
+
+
+      <div style={{ marginTop: '2rem' }}>
+        <h2>Getting Started</h2>
+        <p>
+          To learn more about Purenow and how to build your own serverless React applications,
+          visit the documentation or explore the source code.
+        </p>
+      </div>
+
+      <div style={{ marginTop: '2rem' }}>
+        <Link to="/" style={{ color: '#0066cc', textDecoration: 'none' }}>
+          ← Back to Home
+        </Link>
+      </div>
+    </div>
+  );
+};
+
+export default UsersPage;

package/out/dist/bin/templates/runtime-web/purenow-basic/src/routes.tsx

@@ -0,0 +1,61 @@
+/*
+ * Elastic License 2.0
+ * Copyright (C) 2025–present Raman Marozau, Work Target Insight Function. All rights reserved.
+ * Contact: raman@worktif.com
+ *
+ * This file is part of the Licensed Work: worktif.purenow.cdk <worktif_purenow_cdk>.
+ * Use of this software is governed by the Elastic License 2.0; see the LICENSE file
+ * or https://www.elastic.co/licensing/elastic-license for details.
+ *
+ * Re-licensing notice:
+ *   This file was previously distributed under the Business Source License 1.1 (BUSL-1.1).
+ *   As of 2025-09-22, it is re-licensed under Elastic License 2.0.
+ *
+ * SPDX-License-Identifier: Elastic-2.0
+ */
+
+import * as React from 'react';
+import { Outlet } from 'react-router';
+import { PurenowHeadManager } from '@worktif/purenow';
+
+import HomePage from './pages/HomePage';
+import AboutPage from './pages/AboutPage';
+import UsersPage from './pages/UsersPage';
+
+/**
+ * Purenow routes definition for React Router v7.
+ *
+ * The root route provides a shared layout that mounts the PurenowHeadManager
+ * above the Outlet so SEO metadata are managed centrally for all child routes.
+ * Paths are constructed via Purenow's routePath helper to keep URLs consistent
+ * across different deployment stages (dev, staging, prod).
+ */
+export const routes = [
+  {
+    path: '/',
+    id: 'root',
+    Component: () => (
+      <>
+        <PurenowHeadManager/>
+        <Outlet/>
+      </>
+    ),
+    children: [
+      {
+        path: '/',
+        id: 'home',
+        Component: HomePage,
+      },
+      {
+        path: '/about',
+        id: 'about',
+        Component: AboutPage,
+      },
+      {
+        id: '3',
+        path: '/users',
+        element: <UsersPage/>
+      },
+    ],
+  },
+];

package/out/dist/bin/templates/runtime-web/purenow-basic/src/services/index.ts

@@ -0,0 +1,17 @@
+/*
+ * Elastic License 2.0
+ * Copyright (C) 2025–present Raman Marozau, Work Target Insight Function. All rights reserved.
+ * Contact: raman@worktif.com
+ *
+ * This file is part of the Licensed Work: React Serverless <react-serverless>.
+ * Use of this software is governed by the Elastic License 2.0; see the LICENSE file
+ * or https://www.elastic.co/licensing/elastic-license for details.
+ *
+ * Re-licensing notice:
+ *   This file was previously distributed under the Business Source License 1.1 (BUSL-1.1).
+ *   As of 2025-09-15, it is re-licensed under Elastic License 2.0.
+ *
+ * SPDX-License-Identifier: Elastic-2.0
+ */
+
+export * from './users.service';

package/out/dist/bin/templates/runtime-web/purenow-basic/src/services/users.service.ts

@@ -0,0 +1,133 @@
+/*
+ * Elastic License 2.0
+ * Copyright (C) 2025–present Raman Marozau, Work Target Insight Function. All rights reserved.
+ * Contact: raman@worktif.com
+ *
+ * This file is part of the Licensed Work: worktif.purenow.cdk <worktif_purenow_cdk>.
+ * Use of this software is governed by the Elastic License 2.0; see the LICENSE file
+ * or https://www.elastic.co/licensing/elastic-license for details.
+ *
+ * SPDX-License-Identifier: Elastic-2.0
+ */
+
+/**
+ * User data structure
+ */
+export interface User {
+  id: string;
+  email: string;
+  name: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * User creation input
+ */
+export interface CreateUserInput {
+  email: string;
+  name: string;
+  password: string;
+}
+
+export interface PurenowServiceInterface {
+}
+
+/**
+ * Users Service
+ *
+ * Handles user management, profile operations, and user data.
+ * This service is registered as a singleton in the DI container.
+ */
+export class UsersService implements PurenowServiceInterface {
+  /**
+   * Create a new user
+   *
+   * @param input - User creation data
+   * @returns Created user
+   */
+  async createUser(input: CreateUserInput): Promise<User> {
+    if (!input.email) {
+      throw new Error('Email is required');
+    }
+    if (!input.name) {
+      throw new Error('Name is required');
+    }
+    if (!input.password || input.password.length < 8) {
+      throw new Error('Password must be at least 8 characters');
+    }
+
+    const userId = `user_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const now = new Date().toISOString();
+
+    return {
+      id: userId,
+      email: input.email,
+      name: input.name,
+      createdAt: now,
+      updatedAt: now,
+    };
+  }
+
+  /**
+   * Get user by ID
+   *
+   * @param userId - User identifier
+   * @returns User data or null if not found
+   */
+  async getUser(userId: string): Promise<User | null> {
+    if (!userId) {
+      throw new Error('User ID is required');
+    }
+
+    // Simulate user lookup (would query database in real implementation)
+    return {
+      id: userId,
+      email: 'user@example.com',
+      name: 'Example User',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Update user profile
+   *
+   * @param userId - User identifier
+   * @param updates - Fields to update
+   * @returns Updated user
+   */
+  async updateUser(userId: string, updates: Partial<Pick<User, 'name' | 'email'>>): Promise<User> {
+    if (!userId) {
+      throw new Error('User ID is required');
+    }
+
+    const existingUser = await this.getUser(userId);
+    if (!existingUser) {
+      throw new Error('User not found');
+    }
+
+    return {
+      ...existingUser,
+      ...updates,
+      updatedAt: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Delete user
+   *
+   * @param userId - User identifier
+   * @returns Deletion result
+   */
+  async deleteUser(userId: string): Promise<{ success: boolean; userId: string }> {
+    if (!userId) {
+      throw new Error('User ID is required');
+    }
+
+    return {
+      success: true,
+      userId,
+    };
+  }
+}

package/out/dist/bin/templates/runtime-web/purenow-basic/src/ties/index.ts

@@ -0,0 +1,17 @@
+/*
+ * Elastic License 2.0
+ * Copyright (C) 2025–present Raman Marozau, Work Target Insight Function. All rights reserved.
+ * Contact: raman@worktif.com
+ *
+ * This file is part of the Licensed Work: React Serverless <react-serverless>.
+ * Use of this software is governed by the Elastic License 2.0; see the LICENSE file
+ * or https://www.elastic.co/licensing/elastic-license for details.
+ *
+ * Re-licensing notice:
+ *   This file was previously distributed under the Business Source License 1.1 (BUSL-1.1).
+ *   As of 2025-09-15, it is re-licensed under Elastic License 2.0.
+ *
+ * SPDX-License-Identifier: Elastic-2.0
+ */
+
+export * from './users.ties';

package/out/dist/bin/templates/runtime-web/purenow-basic/src/ties/users.ties.ts

@@ -0,0 +1,53 @@
+/*
+ * Elastic License 2.0
+ * Copyright (C) 2025–present Raman Marozau, Work Target Insight Function. All rights reserved.
+ * Contact: raman@worktif.com
+ *
+ * This file is part of the Licensed Work: worktif.purenow.cdk <worktif_purenow_cdk>.
+ * Use of this software is governed by the Elastic License 2.0; see the LICENSE file
+ * or https://www.elastic.co/licensing/elastic-license for details.
+ *
+ * SPDX-License-Identifier: Elastic-2.0
+ */
+
+import type { PureContainer } from '@worktif/utils';
+
+import { UsersService } from '@bin/templates/runtime-web/purenow-basic/src/services/users.service';
+
+/**
+ * Users configuration
+ */
+export interface UsersConfig {
+  sessionTimeout: number;
+  maxLoginAttempts: number;
+}
+
+/**
+ * Users Ties Class
+ *
+ * Registers all user-related services and configuration in the DI container.
+ *
+ * @example
+ * ```typescript
+ * const definition: MicroserviceDefinition = {
+ *   ties: [UsersTies],
+ *   lambdas: [createUserHandler, getUserHandler]
+ * };
+ * ```
+ */
+export class UsersTies {
+  /**
+   * Register services and constants in the container
+   *
+   * @param container - PureContainer instance
+   */
+  register(container: PureContainer<string>): void {
+    // Register singleton services
+    container.tie({
+      ['usersService']: {
+        instance: UsersService,
+        dependencies: [],
+      },
+    });
+  }
+}

package/out/dist/bin/templates/runtime-web/purenow-basic/tsconfig.json

@@ -0,0 +1,53 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": [
+      "ES2020",
+      "dom",
+      "dom.iterable"
+    ],
+    "jsx": "react",
+    "sourceMap": true,
+    "declaration": true,
+    "outDir": "./out/dist",
+    "rootDir": "./",
+    "baseUrl": "./",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node16",
+    "allowSyntheticDefaultImports": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "isolatedModules": false,
+    "downlevelIteration": true,
+    "allowJs": true,
+    "types": [
+      "node"
+    ],
+    "paths": {
+      "@core/*": [
+        "src/core/*"
+      ],
+      "@lib/*": [
+        "src/lib/*"
+      ],
+      "@utils/*": [
+        "src/utils/*"
+      ]
+    }
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx"
+  ],
+  "exclude": [
+    "node_modules",
+    "out",
+    "dist",
+    "build"
+  ]
+}

package/out/dist/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@worktif/purenow';
+export * from './lib/runtime-web';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/out/dist/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";var w=Object.create;var a=Object.defineProperty;var y=Object.getOwnPropertyDescriptor;var R=Object.getOwnPropertyNames;var v=Object.getPrototypeOf,h=Object.prototype.hasOwnProperty;var b=(t,r)=>{for(var e in r)a(t,e,{get:r[e],enumerable:!0})},m=(t,r,e,o)=>{if(r&&typeof r=="object"||typeof r=="function")for(let n of R(r))!h.call(t,n)&&n!==e&&a(t,n,{get:()=>r[n],enumerable:!(o=y(r,n))||o.enumerable});return t};var E=(t,r,e)=>(e=t!=null?w(v(t)):{},m(r||!t||!t.__esModule?a(e,"default",{value:t,enumerable:!0}):e,t)),C=t=>m(a({},"__esModule",{value:!0}),t);var S={};b(S,{BrowserPipeline:()=>s,ConfigValidationError:()=>d,EnvironmentDetectionError:()=>p,isValidServiceName:()=>g,pureweb:()=>N});module.exports=C(S);var c=E(require("react")),l=require("react-dom/client"),u=require("react-router"),s=class{async execute(r,e){try{console.info("Starting browser pipeline execution",{serviceName:r.serviceName,stage:r.stage,url:e.metadata.url,userAgent:e.metadata.userAgent,viewport:e.metadata.viewport});let o=this.createBrowserRouter(r),n=this.createAppElement(r),f=c.createElement(u.RouterProvider,{router:o},n);this.hydrateApplication(f),this.setupHttpClient(r),console.info("Browser pipeline execution completed successfully",{serviceName:r.serviceName,stage:r.stage})}catch(o){throw console.error("Browser pipeline execution failed",{serviceName:r.serviceName,stage:r.stage,error:o instanceof Error?o.message:String(o),stack:o instanceof Error?o.stack:void 0}),o}}createBrowserRouter(r){console.debug("Creating browser router",{routeCount:r.router.getRoutes().length});let e=r.router.getRoutes(),o=(0,u.createBrowserRouter)(e);return console.debug("Browser router created successfully",{routeCount:e.length}),o}createAppElement(r){console.debug("Creating app element from factory");try{let e=r.app({router:r.router});if(!c.isValidElement(e))throw new Error("App factory must return a valid React element");return console.debug("App element created successfully"),e}catch(e){throw console.error("Failed to create app element",{error:e instanceof Error?e.message:String(e)}),new Error(`Failed to create app element: ${e instanceof Error?e.message:String(e)}`)}}hydrateApplication(r){console.debug("Starting React hydration");try{let e=document.getElementById("root");if(!e)throw new Error('Root container element not found. Expected element with id="root"');(0,l.hydrateRoot)(e,r),console.info("React hydration completed successfully")}catch(e){throw console.error("React hydration failed",{error:e instanceof Error?e.message:String(e)}),new Error(`React hydration failed: ${e instanceof Error?e.message:String(e)}`)}}setupHttpClient(r){console.debug("Setting up HTTP client for Lambda endpoints");try{let e=this.getApiBaseUrl(r.stage);typeof window<"u"&&(window.__PURENOW_CONFIG__={serviceName:r.serviceName,stage:r.stage,apiBaseUrl:e}),console.info("HTTP client configured successfully",{baseUrl:e,stage:r.stage})}catch(e){throw console.error("Failed to setup HTTP client",{error:e instanceof Error?e.message:String(e)}),new Error(`Failed to setup HTTP client: ${e instanceof Error?e.message:String(e)}`)}}getApiBaseUrl(r){return`${typeof window<"u"?window.location.origin:""}/api`}};function g(t){return/^[a-zA-Z][a-zA-Z0-9-]{0,127}$/.test(t)}var i=require("@worktif/purenow"),d=class extends Error{constructor(r){super(`Configuration validation failed:
+${r.map(e=>`  - ${e}`).join(`
+`)}`),this.name="ConfigValidationError",this.errors=r,Error.captureStackTrace(this,this.constructor)}},p=class extends Error{constructor(r){super(r),this.name="EnvironmentDetectionError",Error.captureStackTrace(this,this.constructor)}};function T(){return typeof window<"u"?"browser":typeof process<"u"&&process.env?.AWS_LAMBDA_FUNCTION_NAME?"lambda":(typeof process<"u"&&(process.env?.PURENOW_MODE==="cdk"||process.env?.CDK_DEFAULT_ACCOUNT||process.env?.CDK_DEFAULT_REGION||process.argv?.some(t=>t.includes("cdk")||t.includes("synth"))),"cdk")}function x(t,r){let e=[];return(!t.serviceName||!/^[a-zA-Z][a-zA-Z0-9-]{0,127}$/.test(t.serviceName))&&e.push("serviceName must start with a letter, contain only alphanumeric characters and hyphens, and be max 128 characters"),["dev","staging","prod"].includes(t.stage)||e.push("stage must be one of: dev, staging, prod"),r&&!t.infra&&e.push("infra configuration is required in CDK context"),{valid:e.length===0,errors:e}}function N(t){let r=T(),o=x(t,r==="cdk");if(!o.valid)throw new d(o.errors);switch(r){case"browser":{(0,i.purenow)({app:({router:n})=>t.app({router:n}),router:(0,i.purenowRouter)({router:t.router.getRoutes(),defaults:t.router.defaults}),config:{serviceName:t.serviceName,stage:t.stage}});break}case"lambda":case"cdk":{console.log("[Runtime Target] Server-side pipeline detected (%s)",r),(0,i.purenow)({app:({router:n})=>t.app({router:n}),router:(0,i.purenowRouter)({router:t.router.getRoutes(),defaults:t.router.defaults}),config:{serviceName:t.serviceName,stage:t.stage}});break}default:console.log("[Runtime Target] Unknown environment type: %s",r);break}}0&&(module.exports={BrowserPipeline,ConfigValidationError,EnvironmentDetectionError,isValidServiceName,pureweb});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/lib/runtime-web/index.ts", "../../../src/lib/runtime-web/pipelines/browser-pipeline.ts", "../../../src/lib/runtime-web/types/config.types.ts", "../../../src/lib/runtime-web/pureweb.ts"],
  "sourcesContent": ["/*\n * Elastic License 2.0\n * Copyright (C) 2025\u2013present Raman Marozau, Work Target Insight Function. All rights reserved.\n * Contact: raman@worktif.com\n *\n * This file is part of the Licensed Work: worktif.purenow.cdk <worktif_purenow_cdk>.\n * Use of this software is governed by the Elastic License 2.0; see the LICENSE file\n * or https://www.elastic.co/licensing/elastic-license for details.\n *\n * Re-licensing notice:\n *   This file was previously distributed under the Business Source License 1.1 (BUSL-1.1).\n *   As of 2025-09-22, it is re-licensing under Elastic License 2.0.\n *\n * SPDX-License-Identifier: Elastic-2.0\n */\n\n/**\n * Runtime Web Core - Library (Isomorphic/Browser)\n *\n * **ARCHITECTURE NOTE**: This module contains browser-safe code that:\n * - Runs in browser environment (client-side)\n * - Uses browser APIs (window, document, hydrateRoot)\n * - Must be isomorphic-safe (no Node.js APIs)\n * - NEVER runs in Lambda\n * - Bundled into browser builds\n *\n * **Exports**:\n * - BrowserPipeline: Client-side React hydration and routing\n */\n\nexport * from './pipelines';\nexport * from './types';\nexport * from './pureweb';\n", "/*\n * Elastic License 2.0\n * Copyright (C) 2025\u2013present Raman Marozau, Work Target Insight Function. All rights reserved.\n * Contact: raman@worktif.com\n *\n * This file is part of the Licensed Work: worktif.purenow.cdk <worktif_purenow_cdk>.\n * Use of this software is governed by the Elastic License 2.0; see the LICENSE file\n * or https://www.elastic.co/licensing/elastic-license for details.\n *\n * Re-licensing notice:\n *   This file was previously distributed under the Business Source License 1.1 (BUSL-1.1).\n *   As of 2025-09-22, it is re-licensing under Elastic License 2.0.\n *\n * SPDX-License-Identifier: Elastic-2.0\n */\n\nimport * as React from 'react';\nimport { hydrateRoot } from 'react-dom/client';\nimport { createBrowserRouter, RouterProvider } from 'react-router';\n\nimport type { BrowserMetadata, RuntimeWebConfig } from '@lib/runtime-web/types';\n\n// import { logger } from '@worktif/utils';\n\n/**\n * Browser execution pipeline for Runtime Target Core.\n *\n * @todo: ordinate this class to infra or core cause we have Node.js responsibility\n *      ---- OR \u2013> REMOVE LOGGER\n *\n * **ARCHITECTURE NOTE**: This file is in `src/lib/` because it:\n * - Uses browser-only APIs (window, document, hydrateRoot)\n * - Runs ONLY in browser environment\n * - Must be isomorphic-safe (no Node.js APIs)\n * - NEVER runs in Lambda\n *\n * Handles client-side hydration of React applications with pre-loaded data\n * from server-side rendering. Sets up client-side routing and HTTP client\n * for post-hydration API calls to Lambda endpoints.\n *\n * **Execution Flow**:\n * 1. Hydrate React app with existing PurenowRouter\n * 2. Call config.app({ router }) to get React element\n * 3. Initialize client-side navigation\n * 4. Set up HTTP client for Lambda endpoint calls\n *\n * **Requirements**: REQ-06, REQ-12\n */\nexport class BrowserPipeline {\n  // private readonly logger = logger({\n  //   serviceName: '@lib/runtime-web/pipelines/browser-pipeline',\n  // });\n\n  /**\n   * Execute browser pipeline for client-side hydration.\n   *\n   * Hydrates the React application with pre-loaded data from SSR and sets up\n   * client-side routing. Uses React hydration (not render) to match the\n   * server-rendered HTML exactly.\n   *\n   * @param config - Purenow configuration with app factory and router\n   * @param context - Browser environment context with metadata\n   *\n   * @example\n   * ```typescript\n   * const pipeline = new BrowserPipeline();\n   * await pipeline.execute(config, {\n   *   type: 'browser',\n   *   metadata: {\n   *     userAgent: navigator.userAgent,\n   *     url: window.location.href,\n   *     viewport: { width: window.innerWidth, height: window.innerHeight }\n   *   }\n   * });\n   * ```\n   */\n  async execute(config: RuntimeWebConfig, context: { type: 'browser'; metadata: BrowserMetadata }): Promise<void> {\n    try {\n      console.info('Starting browser pipeline execution', {\n        serviceName: config.serviceName,\n        stage: config.stage,\n        url: context.metadata.url,\n        userAgent: context.metadata.userAgent,\n        viewport: context.metadata.viewport,\n      });\n\n      // 1. Create browser router from PurenowRouter\n      const browserRouter = this.createBrowserRouter(config);\n\n      // 2. Get React element from app factory\n      const appElement = this.createAppElement(config);\n\n      // 3. Create router provider with the app\n      const routerProvider = React.createElement(RouterProvider, {\n        router: browserRouter,\n      }, appElement);\n\n      // 4. Hydrate the application (use hydration, not render)\n      this.hydrateApplication(routerProvider);\n\n      // 5. Set up HTTP client for post-hydration API calls\n      this.setupHttpClient(config);\n\n      console.info('Browser pipeline execution completed successfully', {\n        serviceName: config.serviceName,\n        stage: config.stage,\n      });\n\n    } catch (error) {\n      console.error('Browser pipeline execution failed', {\n        serviceName: config.serviceName,\n        stage: config.stage,\n        error: error instanceof Error ? error.message : String(error),\n        stack: error instanceof Error ? error.stack : undefined,\n      });\n      throw error;\n    }\n  }\n\n  /**\n   * Create browser router from PurenowRouter configuration.\n   *\n   * Uses the existing PurenowRouter to get routes and creates a React Router\n   * browser router for client-side navigation.\n   *\n   * @param config - Purenow configuration\n   * @returns Browser router instance\n   * @private\n   */\n  private createBrowserRouter(config: RuntimeWebConfig) {\n    console.debug('Creating browser router', {\n      routeCount: config.router.getRoutes().length,\n    });\n\n    // Get routes from PurenowRouter\n    const routes = config.router.getRoutes();\n\n    // Create browser router with routes (cast to RouteObject[] for compatibility)\n    const browserRouter = createBrowserRouter(routes as any);\n\n    console.debug('Browser router created successfully', {\n      routeCount: routes.length,\n    });\n\n    return browserRouter;\n  }\n\n  /**\n   * Create React element from app factory function.\n   *\n   * Calls the user's app factory function with the router dependency\n   * to get the root React element for the application.\n   *\n   * @param config - Purenow configuration\n   * @returns Root React element\n   * @private\n   */\n  private createAppElement(config: RuntimeWebConfig): React.ReactElement {\n    console.debug('Creating app element from factory');\n\n    try {\n      // Call app factory with router dependency\n      const appElement = config.app({ router: config.router });\n\n      if (!React.isValidElement(appElement)) {\n        throw new Error('App factory must return a valid React element');\n      }\n\n      console.debug('App element created successfully');\n      return appElement;\n\n    } catch (error) {\n      console.error('Failed to create app element', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n      throw new Error(`Failed to create app element: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  /**\n   * Hydrate the React application in the browser.\n   *\n   * Uses React's hydrateRoot to hydrate the server-rendered HTML with\n   * the client-side React application. This ensures the client matches\n   * the server exactly to avoid hydration mismatches.\n   *\n   * @param routerProvider - Router provider element to hydrate\n   * @private\n   */\n  private hydrateApplication(routerProvider: React.ReactElement): void {\n    console.debug('Starting React hydration');\n\n    try {\n      // Get the root container element\n      const container = document.getElementById('root');\n      if (!container) {\n        throw new Error('Root container element not found. Expected element with id=\"root\"');\n      }\n\n      // Hydrate the application (not render - must match server HTML)\n      hydrateRoot(container, routerProvider);\n\n      console.info('React hydration completed successfully');\n\n    } catch (error) {\n      console.error('React hydration failed', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n      throw new Error(`React hydration failed: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  /**\n   * Set up HTTP client for Lambda endpoint calls.\n   *\n   * Configures the HTTP client for making API calls to Lambda endpoints\n   * after hydration. This is used for post-hydration interactions that\n   * require server-side data.\n   *\n   * @param config - Purenow configuration\n   * @private\n   */\n  private setupHttpClient(config: RuntimeWebConfig): void {\n    console.debug('Setting up HTTP client for Lambda endpoints');\n\n    try {\n      // Set up base URL for API calls based on stage\n      const baseUrl = this.getApiBaseUrl(config.stage);\n\n      // Store configuration globally for use by data loaders\n      if (typeof window !== 'undefined') {\n        (window as any).__PURENOW_CONFIG__ = {\n          serviceName: config.serviceName,\n          stage: config.stage,\n          apiBaseUrl: baseUrl,\n        };\n      }\n\n      console.info('HTTP client configured successfully', {\n        baseUrl,\n        stage: config.stage,\n      });\n\n    } catch (error) {\n      console.error('Failed to setup HTTP client', {\n        error: error instanceof Error ? error.message : String(error),\n      });\n      throw new Error(`Failed to setup HTTP client: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  /**\n   * Get API base URL based on deployment stage.\n   *\n   * Determines the appropriate API base URL for making HTTP requests\n   * to Lambda endpoints based on the deployment stage.\n   *\n   * @param stage - Deployment stage\n   * @returns API base URL\n   * @private\n   */\n  private getApiBaseUrl(stage: 'dev' | 'staging' | 'prod'): string {\n    // In browser context, API calls go through the same origin\n    // The actual API Gateway URL is handled by CloudFront routing\n    const origin = typeof window !== 'undefined' ? window.location.origin : '';\n\n    // API endpoints are typically under /api path\n    return `${origin}/api`;\n  }\n}\n", "/*\n * Elastic License 2.0\n * Copyright (C) 2025\u2013present Raman Marozau, Work Target Insight Function. All rights reserved.\n * Contact: raman@worktif.com\n *\n * This file is part of the Licensed Work: worktif.purenow.cdk <worktif_purenow_cdk>.\n * Use of this software is governed by the Elastic License 2.0; see the LICENSE file\n * or https://www.elastic.co/licensing/elastic-license for details.\n *\n * Re-licensing notice:\n *   This file was previously distributed under the Business Source License 1.1 (BUSL-1.1).\n *   As of 2025-09-22, it is re-licensed under Elastic License 2.0.\n *\n * SPDX-License-Identifier: Elastic-2.0\n */\n\nimport * as React from 'react';\nimport type { InfraOptions } from './infra.types';\nimport type { MicroserviceDefinition } from './microservice.types';\n\n/**\n * PurenowRouter interface for runtime-web integration.\n *\n * Defines the essential methods needed by the runtime-web pipelines.\n * This interface matches the actual PurenowRouter class from @lib/react/purenow.router.\n */\ninterface PurenowRouter {\n  /**\n   * Get all route objects as an array.\n   * Used for creating browser routers and SSR static handlers.\n   */\n  getRoutes(): Array<{\n    path?: string;\n    element?: unknown;\n    loader?: unknown;\n    children?: unknown;\n    [key: string]: unknown;\n  }>;\n\n  /**\n   * Find a route by its ID.\n   */\n  getRouteById?(id: string): unknown;\n\n  /**\n   * Find a route by its path.\n   */\n  getRouteByPath?(path: string): unknown;\n\n  /**\n   * Get the routes array (getter).\n   */\n  routes?: Array<unknown>;\n\n  /**\n   * Get the default configuration.\n   */\n  defaults?: unknown;\n}\n\n/**\n * Stage environment for deployment.\n *\n * - `dev`: Development environment\n * - `staging`: Staging/pre-production environment\n * - `prod`: Production environment\n */\nexport type Stage = 'dev' | 'staging' | 'prod';\n\n/**\n * Utility type to extract service names from register configuration.\n *\n * This enables compile-time validation of service names and provides\n * type-safe access to service identifiers throughout the framework.\n *\n * @template T - The register configuration object type\n */\nexport type ServiceNames<T extends Record<string, MicroserviceDefinition>> = keyof T;\n\n/**\n * Utility type to generate Lambda IDs from service configuration.\n *\n * Combines service names with Lambda IDs to create fully qualified\n * Lambda identifiers for type-safe Lambda resolution.\n *\n * @template T - The register configuration object type\n */\nexport type LambdaIds<T extends Record<string, MicroserviceDefinition>> = {\n  [K in keyof T]: T[K]['lambdas'][number] extends { id: infer I }\n    ? I extends string\n      ? `${K & string}.${I}`\n      : never\n    : never;\n}[keyof T];\n\n/**\n * Type constraint for valid service names.\n *\n * Ensures service names follow the validation pattern:\n * - Must start with a letter (a-z, A-Z)\n * - Can contain letters, numbers, and hyphens\n * - Maximum length: 128 characters\n *\n * This is a branded type that provides compile-time validation.\n */\nexport type ValidServiceName = string & { readonly __brand: 'ValidServiceName' };\n\n/**\n * Type guard to validate service name format.\n *\n * @param serviceName - The service name to validate\n * @returns Type predicate indicating if the service name is valid\n */\nexport function isValidServiceName(serviceName: string): serviceName is ValidServiceName {\n  return /^[a-zA-Z][a-zA-Z0-9-]{0,127}$/.test(serviceName);\n}\n\n/**\n * Main configuration interface for Runtime Target Core.\n *\n * This interface provides a unified configuration that works across all execution contexts:\n * - Browser: Hydrates React application with client-side routing\n * - Lambda: Executes server-side rendering and business logic\n * - CDK: Synthesizes CloudFormation infrastructure\n *\n * @template TRegister - The register configuration type for type-safe service names\n *\n * @example\n * ```typescript\n * import { purenow } from '@worktif/purenow/runtime-web';\n * import { PurenowRouter } from '@worktif/purenow';\n *\n * const config = {\n *   app: ({ router }) => <App router={router} />,\n *   router: new PurenowRouter({ router: routes, defaults: {} }),\n *   serviceName: 'my-app',\n *   stage: 'dev',\n *   register: {\n *     payments: {\n *       ties: [PaymentsTies],\n *       lambdas: [chargeHandler, refundHandler]\n *     },\n *     users: {\n *       ties: [UsersTies],\n *       lambdas: [createUserHandler, getUserHandler]\n *     }\n *   } as const,  // Use 'as const' for better type inference\n *   infra: {\n *     env: { account: '123456789012', region: 'us-east-1' },\n *     stage: 'dev',\n *     reactEntry: './src/index.tsx',\n *     apiMode: 'apiGateway'\n *   }\n * } satisfies PurenowConfig;\n *\n * purenow(config);\n * ```\n *\n * @todo: after RuntimeWeb repo will be resolved, RuntimeWebConfig MUST extend PurenowConfig Core\n */\nexport interface RuntimeWebConfig<TRegister extends Record<string, MicroserviceDefinition> = Record<string, MicroserviceDefinition>> {\n  /**\n   * React application component factory function.\n   *\n   * Receives the router instance as a dependency and returns the root React element.\n   * This pattern enables dependency injection of the router into your application.\n   *\n   * @param deps - Dependencies object containing the router\n   * @param deps.router - PurenowRouter instance for navigation and routing\n   * @returns Root React element (React.ReactElement)\n   *\n   * @example\n   * ```typescript\n   * app: ({ router }) => <App router={router} />\n   * ```\n   */\n  app: (deps: { router: PurenowRouter }) => React.ReactElement;\n\n  /**\n   * PurenowRouter instance for application routing.\n   *\n   * Defines all routes, loaders, and navigation configuration.\n   * The router is used in both server-side rendering (Lambda) and client-side hydration (browser).\n   *\n   * @see {@link PurenowRouter} for router configuration\n   *\n   * @example\n   * ```typescript\n   * router: new PurenowRouter({\n   *   router: [\n   *     { path: '/', element: <Home /> },\n   *     { path: '/about', element: <About /> }\n   *   ],\n   *   defaults: {}\n   * })\n   * ```\n   */\n  router: PurenowRouter;\n\n  /**\n   * Service name identifier for the application.\n   *\n   * Used as a prefix for all AWS resources (Lambda functions, API Gateway, S3 buckets, etc.).\n   * Must be unique within your AWS account and region.\n   *\n   * **Validation Rules**:\n   * - Must start with a letter (a-z, A-Z)\n   * - Can contain letters, numbers, and hyphens\n   * - Maximum length: 128 characters\n   * - Pattern: `/^[a-zA-Z][a-zA-Z0-9-]{0,127}$/`\n   *\n   * **Examples**:\n   * - Valid: `my-app`, `MyApp`, `app123`, `my-app-v2`\n   * - Invalid: `123app` (starts with number), `my_app` (underscore), `my app` (space)\n   *\n   * @example\n   * ```typescript\n   * serviceName: 'my-application'\n   * ```\n   */\n  serviceName: string;\n\n  /**\n   * Deployment stage/environment.\n   *\n   * Determines the environment-specific configuration and resource naming.\n   * Used to create separate infrastructure stacks for different environments.\n   *\n   * **Values**:\n   * - `dev`: Development environment (local testing, rapid iteration)\n   * - `staging`: Staging/pre-production environment (QA, integration testing)\n   * - `prod`: Production environment (live users)\n   *\n   * **Impact**:\n   * - Resource naming: `{serviceName}-{resource}-{stage}`\n   * - Environment variables: Different configs per stage\n   * - Cache TTL: Shorter in dev, longer in prod\n   * - Logging: More verbose in dev, structured in prod\n   *\n   * @example\n   * ```typescript\n   * stage: 'dev'\n   * ```\n   */\n  stage: Stage;\n\n  /**\n   * Microservice registry (runtime-level configuration).\n   *\n   * **Required**: Defines all microservices, their DI containers, and Lambda endpoints.\n   * **Used in all contexts**: Browser (for type generation), Lambda (for DI), CDK (for infrastructure).\n   * **Architecture**: This is runtime configuration, separate from infrastructure concerns.\n   *\n   * Each microservice gets its own PureContainer instance built from the Ties classes.\n   * Lambda functions are automatically created and wired with dependency injection.\n   *\n   * **Type Safety**: Service names are derived from object keys, ensuring compile-time validation.\n   * **No Magic Strings**: All service identifiers are type-safe and auto-generated.\n   *\n   * @see {@link MicroserviceDefinition} for microservice structure\n   *\n   * @example\n   * ```typescript\n   * register: {\n   *   payments: {\n   *     ties: [PaymentsTies, BillingTies],\n   *     lambdas: [chargeHandler, refundHandler, webhookHandler]\n   *   },\n   *   users: {\n   *     ties: [UsersTies, AuthTies],\n   *     lambdas: [createUserHandler, getUserHandler, loginHandler]\n   *   }\n   * } as const  // Use 'as const' for better type inference\n   * ```\n   */\n  register: TRegister;\n\n  /**\n   * Infrastructure configuration for CDK deployment.\n   *\n   * **Optional**: Only required when running in CDK context (synthesizing CloudFormation templates).\n   * **Not used**: In browser and Lambda contexts (runtime configuration is in register).\n   * **Pure infrastructure**: Contains only AWS resource configuration, no business logic.\n   *\n   * Defines:\n   * - AWS account and region\n   * - Lambda configuration (memory, timeout, VPC)\n   * - API Gateway or Lambda URL mode\n   * - Custom domain configuration\n   * - React entry point for SSR Lambda\n   *\n   * @see {@link InfraOptions} for detailed configuration options\n   *\n   * @example\n   * ```typescript\n   * infra: {\n   *   env: { account: '123456789012', region: 'us-east-1' },\n   *   stage: 'dev',\n   *   reactEntry: './src/index.tsx',\n   *   apiMode: 'apiGateway',\n   *   lambdaMemorySize: 1024,\n   *   lambdaTimeout: 30,\n   *   domain: {\n   *     rootDomain: 'myapp.com',\n   *     subdomain: 'api'\n   *   }\n   * }\n   * ```\n   */\n  infra?: InfraOptions;\n}\n\n/**\n * Type-safe Purenow configuration with inferred service names.\n *\n * This type provides Runtime Core type safety by inferring service names from the register\n * configuration, enabling compile-time validation of service references.\n *\n * @template TRegister - The register configuration type\n */\nexport type TypeSafePurenowConfig<TRegister extends Record<string, MicroserviceDefinition>> =\n  RuntimeWebConfig<TRegister> & {\n  /**\n   * Type-safe service names derived from register keys.\n   * Available at compile-time for type checking and IDE autocomplete.\n   */\n  readonly serviceNames?: ServiceNames<TRegister>;\n\n  /**\n   * Type-safe Lambda IDs derived from register configuration.\n   * Available at compile-time for type checking and IDE autocomplete.\n   */\n  readonly lambdaIds?: LambdaIds<TRegister>;\n};\n", "/*\n * Elastic License 2.0\n * Copyright (C) 2025\u2013present Raman Marozau, Work Target Insight Function. All rights reserved.\n * Contact: raman@worktif.com\n *\n * This file is part of the Licensed Work: worktif.purenow.cdk <worktif_purenow_cdk>.\n * Use of this software is governed by the Elastic License 2.0; see the LICENSE file\n * or https://www.elastic.co/licensing/elastic-license for details.\n *\n * Re-licensing notice:\n *   This file was previously distributed under the Business Source License 1.1 (BUSL-1.1).\n *   As of 2025-09-22, it is re-licensed under Elastic License 2.0.\n *\n * SPDX-License-Identifier: Elastic-2.0\n */\n\nimport type { RuntimeWebConfig } from './types';\nimport { purenow, PurenowRoute, purenowRouter, PurenowRouterDefaults } from '@worktif/purenow';\n\n/**\n * Error thrown when configuration validation fails.\n * Follows purenow error patterns without emoji.\n */\nexport class ConfigValidationError extends Error {\n  /** Array of validation error messages */\n  readonly errors: string[];\n\n  constructor(errors: string[]) {\n    super(`Configuration validation failed:\\n${errors.map(e => `  - ${e}`).join('\\n')}`);\n    this.name = 'ConfigValidationError';\n    this.errors = errors;\n    Error.captureStackTrace(this, this.constructor);\n  }\n}\n\n/**\n * Error thrown when environment detection fails.\n * Follows purenow error patterns without emoji.\n */\nexport class EnvironmentDetectionError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'EnvironmentDetectionError';\n    Error.captureStackTrace(this, this.constructor);\n  }\n}\n\n/**\n * Detect the current runtime environment.\n * This is a lightweight detection that works in all environments.\n */\nfunction detectEnvironment(): 'browser' | 'lambda' | 'cdk' {\n  // Browser detection\n  if (typeof window !== 'undefined') {\n    return 'browser';\n  }\n\n  // Lambda detection\n  if (typeof process !== 'undefined' && process.env?.AWS_LAMBDA_FUNCTION_NAME) {\n    return 'lambda';\n  }\n\n  // CDK detection\n  if (typeof process !== 'undefined') {\n    if (process.env?.PURENOW_MODE === 'cdk') {\n      return 'cdk';\n    }\n    if (process.env?.CDK_DEFAULT_ACCOUNT || process.env?.CDK_DEFAULT_REGION) {\n      return 'cdk';\n    }\n    if (process.argv?.some(arg => arg.includes('cdk') || arg.includes('synth'))) {\n      return 'cdk';\n    }\n  }\n\n  // Default to CDK for Node.js environments (build time)\n  return 'cdk';\n}\n\n/**\n * Validate configuration for the given environment.\n * Lightweight validation that works in all environments.\n */\nfunction validateConfig(config: RuntimeWebConfig, isCDKContext: boolean): { valid: boolean; errors: string[] } {\n  const errors: string[] = [];\n\n  // Service name validation\n  if (!config.serviceName || !/^[a-zA-Z][a-zA-Z0-9-]{0,127}$/.test(config.serviceName)) {\n    errors.push('serviceName must start with a letter, contain only alphanumeric characters and hyphens, and be max 128 characters');\n  }\n\n  // Stage validation\n  if (!['dev', 'staging', 'prod'].includes(config.stage)) {\n    errors.push('stage must be one of: dev, staging, prod');\n  }\n\n  // Infra validation for CDK context\n  if (isCDKContext && !config.infra) {\n    errors.push('infra configuration is required in CDK context');\n  }\n\n  return { valid: errors.length === 0, errors };\n}\n\n/**\n * Unified entry point for Runtime Target Core.\n *\n * This function provides a single API that works across all execution contexts:\n * - **Browser**: Hydrates React application with client-side routing\n * - **Lambda**: Executes server-side rendering and business logic with DI\n * - **CDK**: Synthesizes CloudFormation infrastructure templates\n *\n * The function automatically detects the runtime environment and routes\n * execution to the appropriate pipeline without user intervention.\n *\n * **Note**: For Lambda and CDK contexts, use the server-side entry point\n * from `@core/runtime-web` instead. This browser-compatible version\n * only supports browser hydration.\n *\n * @param config - Unified configuration for all contexts\n * @returns Promise that resolves when execution completes\n * @throws ConfigValidationError if configuration is invalid\n * @throws EnvironmentDetectionError if environment cannot be detected\n * @throws Error if execution fails\n *\n * @example\n * ```typescript\n * import { purenow } from '@worktif/purenow/runtime-web';\n * import { PurenowRouter } from '@worktif/purenow';\n *\n * purenow({\n *   app: ({ router }) => <App router={router} />,\n *   router: new PurenowRouter({ routes, defaults: {} }),\n *   serviceName: 'my-app',\n *   stage: 'dev',\n *   register: {\n *     payments: {\n *       ties: [PaymentsTies],\n *       lambdas: [chargeHandler, refundHandler]\n *     }\n *   },\n *   infra: {\n *     env: { account: '123456789012', region: 'us-east-1' },\n *     stage: 'dev',\n *     reactEntry: './src/index.tsx',\n *     apiMode: 'apiGateway'\n *   }\n * });\n * ```\n */\nexport function pureweb(config: RuntimeWebConfig): void {\n  // 1. Detect runtime environment using lightweight detection\n  const envType = detectEnvironment();\n  const isCDKContext = envType === 'cdk';\n\n  // 2. Validate configuration\n  const validationResult = validateConfig(config, isCDKContext);\n\n  if (!validationResult.valid) {\n    throw new ConfigValidationError(validationResult.errors);\n  }\n\n  // 3. Route to appropriate pipeline based on environment\n  switch (envType) {\n    case 'browser': {\n      // Browser pipeline - hydrate React app\n      // This is the only path that runs in the browser\n      purenow({\n        app: ({ router }) => config.app({ router }),\n        router: purenowRouter({\n          router: config.router.getRoutes() as PurenowRoute[],\n          defaults: config.router.defaults as PurenowRouterDefaults,\n        }),\n        config: {\n          serviceName: config.serviceName,\n          stage: config.stage,\n        },\n      });\n      break;\n    }\n\n    case 'lambda':\n    case 'cdk': {\n      // Lambda and CDK pipelines require server-side code\n      // These should use the server-side entry point from @core/runtime-web\n      console.log('[Runtime Target] Server-side pipeline detected (%s)', envType);\n      purenow({\n        app: ({ router }) => config.app({ router }),\n        router: purenowRouter({\n          router: config.router.getRoutes() as PurenowRoute[],\n          defaults: config.router.defaults as PurenowRouterDefaults,\n        }),\n        config: {\n          serviceName: config.serviceName,\n          stage: config.stage,\n        },\n      });\n      break;\n      // console.log('[Purenow] Lambda runtime detected, skipping browser rendering pipeline');\n      // throw new EnvironmentDetectionError(\n      //   `Server-side environment detected (${envType}). ` +\n      //   `Use the server-side entry point from '@core/runtime-web' for Lambda and CDK contexts.`,\n      // );\n    }\n\n    default:\n      console.log('[Runtime Target] Unknown environment type: %s', envType);\n      break;\n    // throw new EnvironmentDetectionError(\n    //   `Unknown environment type: ${envType}`,\n    // );\n  }\n}\n\n/**\n * Execute the browser pipeline for React hydration.\n * This is browser-safe code that doesn't import from @core/.\n */\nasync function executeBrowserPipeline(config: RuntimeWebConfig): Promise<void> {\n  // Ensure we're in a browser environment\n  if (typeof window === 'undefined') {\n    throw new EnvironmentDetectionError('Browser environment required for browser pipeline');\n  }\n\n  // Import React DOM for hydration\n  const { hydrateRoot, createRoot } = await import('react-dom/client');\n  const { createBrowserRouter } = await import('react-router');\n  const React = await import('react');\n\n  // Get DOM elements\n  const rootPurenow = document.getElementById('root-purenow');\n  const rootInternal = document.getElementById('root-internal');\n\n  // Determine which root element to use\n  const rootElement = rootPurenow || rootInternal;\n\n  if (!rootElement) {\n    throw new Error(\n      '[Runtime Target] Root element not found. ' +\n      'Ensure your HTML includes <div id=\"root-purenow\"></div> or <div id=\"root-internal\"></div>',\n    );\n  }\n\n  // Get routes from the router - use routes property or getRoutes method\n  const routes = config.router.routes || (config.router as any).getRoutes?.() || [];\n\n  // Create browser router - cast routes to any to avoid type issues with different react-router versions\n  const browserRouter = createBrowserRouter(routes as any);\n\n  // Create the app element - pass the browser router\n  const AppElement = config.app({ router: browserRouter as any });\n\n  // Check if we should hydrate (SSR HTML exists) or render fresh\n  if (rootPurenow?.hasChildNodes()) {\n    // Hydrate SSR HTML\n    console.log('[Runtime Target] Hydrating SSR HTML...');\n    hydrateRoot(rootElement, React.createElement(React.StrictMode, null, AppElement));\n    console.log('[Runtime Target] Hydration complete');\n  } else {\n    // Fresh render\n    console.log('[Runtime Target] Creating fresh React root...');\n    const root = createRoot(rootElement);\n    root.render(React.createElement(React.StrictMode, null, AppElement));\n    console.log('[Runtime Target] Render complete');\n  }\n}\n"],
  "mappings": "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",
  "names": ["index_exports", "__export", "BrowserPipeline", "ConfigValidationError", "EnvironmentDetectionError", "isValidServiceName", "pureweb", "__toCommonJS", "React", "import_client", "import_react_router", "BrowserPipeline", "config", "context", "browserRouter", "appElement", "routerProvider", "error", "routes", "container", "baseUrl", "stage", "isValidServiceName", "serviceName", "import_purenow", "ConfigValidationError", "errors", "EnvironmentDetectionError", "message", "detectEnvironment", "arg", "validateConfig", "config", "isCDKContext", "pureweb", "envType", "validationResult", "router"]
}


package/out/dist/lib/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from '@worktif/purenow';
+export * from './runtime-web';
+//# sourceMappingURL=index.d.ts.map