@jay-framework/fullstack-component 0.7.0 → 0.9.0

package/README.md

@@ -10,7 +10,8 @@ The `@jay-framework/fullstack-component` package provides a fluent builder API f
 - **Fast Changing Server-side render** with dynamic data on the server
 - **Client-side interactivity** with reactive state management
 - **Type-safe** component contracts using Jay HTML and Jay Contracts
-- **Context-aware** rendering with server and client contexts
+- **Service injection** for server-side dependencies (database, API clients, etc.)
+- **Context support** for client-side hierarchical state
 
 ## Features
 
@@ -18,22 +19,124 @@ The `@jay-framework/fullstack-component` package provides a fluent builder API f
 - ⚡ **Interactive Client**: Seamless client-side interactivity with reactive signals
 - 🎯 **Type Safety**: Full TypeScript support with generated contracts from Jay HTML
 - 🔧 **Fluent Builder API**: Intuitive chainable API for component configuration
-- 🌐 **Context Support**: Server and client context injection
+- 💉 **Service Injection**: Type-safe dependency injection for server-side services
+- 🌐 **Context Support**: Client-side hierarchical context injection
 - 📦 **URL Parameter Loading**: Built-in support for dynamic URL parameter handling
 - 🚀 **Performance Optimized**: Efficient rendering with partial state updates
 
 ## Rendering Phases
 
-- **Slow Rendering**: Use for static data that doesn't change often
-- **Fast Rendering**: Use for dynamic data that can be cached
-- **Partial Renders**: Only update the parts of the view state that change
-- **Carry Forward**: Pass data between render phases to avoid recomputation
+Jay Stack components support three rendering phases, each optimized for different data lifecycles:
 
-| Rendering Phase        | Rendered Where | When Rendered                  | Carry Forward      |
-| ---------------------- | -------------- | ------------------------------ | ------------------ |
-| Slowly Changing Render | SSR            | Build time or data change time | Slowly → Fast      |
-| Fast Changing Render   | SSR            | Page serving                   | Fast → Interactive |
-| Interactive Render     | CSR            | User interaction               | -                  |
+| Rendering Phase    | Rendered Where | When Rendered                  | Use Case                          |
+| ------------------ | -------------- | ------------------------------ | --------------------------------- |
+| **Slow (Static)**  | SSR            | Build time or data change time | Product names, descriptions, SKUs |
+| **Fast (Dynamic)** | SSR            | Page serving (per request)     | Inventory, pricing, availability  |
+| **Interactive**    | CSR            | User interaction               | Cart count, user selections       |
+
+### Phase-Based Type Validation
+
+Jay Stack automatically generates **phase-specific ViewState types** from your contracts, ensuring that each render function can only return properties appropriate for its phase. This prevents accidentally including fast-changing data in slow renders or slow data in fast renders.
+
+**Benefits:**
+
+- 🛡️ **Compile-time safety**: TypeScript catches phase violations before deployment
+- 📝 **Self-documenting**: The contract explicitly shows which data is static vs dynamic
+- ⚡ **Performance**: Ensures optimal caching and rendering strategies
+- 🎯 **Intent clarity**: Makes data lifecycle explicit in the contract
+
+**Example:**
+
+````typescript
+// TypeScript automatically knows which properties are valid in each phase
+.withSlowlyRender(async () => {
+    return partialRender({
+        productName: 'Widget',   // ✅ Allowed (slow phase)
+        price: 29.99,           // ❌ TypeScript Error: Not in SlowViewState
+    }, {});
+})
+.withFastRender(async () => {
+    return partialRender({
+        price: 29.99,           // ✅ Allowed (fast phase)
+        productName: 'Widget',   // ❌ TypeScript Error: Not in FastViewState
+    }, {});
+})
+
+### Specifying Phases in Contracts
+
+You can annotate your contract properties with the `phase` attribute to control when data is rendered:
+
+#### Jay HTML Contract
+
+```html
+<html>
+  <head>
+    <script type="application/yaml-jay">
+      data:
+        # Static data - rendered at build time
+        - {tag: productName, dataType: string, phase: slow}
+        - {tag: description, dataType: string, phase: slow}
+        - {tag: sku, dataType: string, phase: slow}
+
+        # Dynamic data - rendered per request
+        - {tag: price, dataType: number, phase: fast}
+        - {tag: inStock, dataType: boolean, phase: fast}
+
+        # No phase specified = defaults to 'slow'
+        - {tag: category, dataType: string}
+    </script>
+  </head>
+  <body>
+    <div>
+      <h1>{productName}</h1>
+      <p>{description}</p>
+      <p>Price: ${price}</p>
+    </div>
+  </body>
+</html>
+````
+
+#### Jay Contract (Headless)
+
+```yaml
+name: product-contract
+tags:
+  # Static product information
+  - tag: productName
+    dataType: string
+    phase: slow
+
+  - tag: description
+    dataType: string
+    phase: slow
+
+  - tag: sku
+    dataType: string
+    phase: slow
+
+  # Dynamic pricing and availability
+  - tag: price
+    dataType: number
+    phase: fast
+
+  - tag: inStock
+    dataType: boolean
+    phase: fast
+
+  # Interactive elements go in refs, not data
+  interactive:
+    - tag: addToCartButton
+      elementType: [button]
+```
+
+**Phase Rules:**
+
+- `slow`: Value is set at build time (default if not specified)
+- `fast`: Value is set at request time
+- `fast+interactive`: Value is set at request time and can be modified on the client
+- `interactive` tags are implicitly `fast+interactive` and go into the `Refs` type, not `ViewState`
+- For nested objects, the parent's phase serves as the default for children
+- Array children cannot have an earlier phase than their parent array
 
 ## Installation
 
@@ -55,12 +158,15 @@ For headless components, create a Jay Contract file (`my-contract.jay-contract`)
   <head>
     <script type="application/yaml-jay">
       data:
-        id: string
-        name: string
-        age: number
-        address: string
-        stars: number
-        rating: number
+        # User profile data - slow changing
+        - {tag: id, dataType: string, phase: slow}
+        - {tag: name, dataType: string, phase: slow}
+        - {tag: age, dataType: number, phase: slow}
+        - {tag: address, dataType: string, phase: slow}
+
+        # User ratings - fast changing
+        - {tag: stars, dataType: number, phase: fast}
+        - {tag: rating, dataType: number, phase: fast}
     </script>
   </head>
   <body>
@@ -82,18 +188,31 @@ For headless components, create a Jay Contract file (`my-contract.jay-contract`)
 ```yaml
 name: my-contract
 tags:
+  # User profile data - slow changing
   - tag: id
     dataType: string
+    phase: slow
+
   - tag: name
     dataType: string
+    phase: slow
+
   - tag: age
     dataType: number
+    phase: slow
+
   - tag: address
     dataType: string
+    phase: slow
+
+  # User ratings - fast changing
   - tag: stars
     dataType: number
+    phase: fast
+
   - tag: rating
     dataType: number
+    phase: fast
 ```
 
 ### 2. Generate Definition Files
@@ -104,51 +223,104 @@ Run the Jay CLI to generate TypeScript definition files from your Jay HTML or co
 jay-cli definitions <path to your sources>
 ```
 
+This will generate a `.d.ts` file with:
+
+- **Full ViewState**: All properties from your contract
+- **Phase-specific ViewStates**: Separate types for `Slow`, `Fast`, and `Interactive` phases
+- **Contract type**: A `JayContract` type that includes all ViewState types
+
+**Generated Types Example** (`my-component.jay-html.d.ts`):
+
+```typescript
+import { JayContract } from '@jay-framework/fullstack-component';
+
+// Full ViewState - all properties
+export interface MyComponentViewState {
+  id: string;
+  name: string;
+  age: number;
+  address: string;
+  stars: number;
+  rating: number;
+}
+
+export interface MyComponentElementRefs {}
+
+// Phase-specific ViewStates (automatically generated)
+export type MyComponentSlowViewState = Pick<
+  MyComponentViewState,
+  'id' | 'name' | 'age' | 'address'
+>;
+export type MyComponentFastViewState = Pick<MyComponentViewState, 'stars' | 'rating'>;
+export type MyComponentInteractiveViewState = {};
+
+// Contract type with all ViewState types
+export type MyComponentContract = JayContract<
+  MyComponentViewState,
+  MyComponentElementRefs,
+  MyComponentSlowViewState,
+  MyComponentFastViewState,
+  MyComponentInteractiveViewState
+>;
+```
+
 ### 3. Build Your Full-Stack Component
 
 ```typescript
 import { MyComponentContract } from './my-component.jay-html';
 // or import { MyComponentContract } from './my-component.jay-contract';
-import { makeJayStackComponent, partialRender } from '@jay-framework/fullstack-component';
+import {
+  makeJayStackComponent,
+  partialRender,
+  createJayService,
+} from '@jay-framework/fullstack-component';
 import { createJayContext } from '@jay-framework/runtime';
 
-// Define your props and contexts
+// Define your props
 interface MyComponentProps {}
 
-interface MyContext {
-  userId: string;
+// Define services (server-side)
+interface DatabaseService {
+  getUser(id: string): Promise<User>;
 }
+const DATABASE_SERVICE = createJayService<DatabaseService>('Database');
 
-const MyContextMarker = createJayContext<MyContext>();
+// Define contexts (client-side)
+interface ThemeContext {
+  theme: string;
+}
+const ThemeContextMarker = createJayContext<ThemeContext>();
 
 // Create the full-stack component
 export const myComponent = makeJayStackComponent<MyComponentContract>()
   .withProps<MyComponentProps>()
-  .withServerContext(MyContextMarker)
-  .withSlowlyRender(async (props, myContext) => {
+  .withServices(DATABASE_SERVICE)
+  .withContexts(ThemeContextMarker)
+  .withSlowlyRender(async (props, database) => {
     // Slow rendering - static data that doesn't change often
+    const user = await database.getUser('1');
     return partialRender(
       {
-        id: '1',
-        name: 'John Doe',
-        age: 30,
-        address: '123 Main St, City, State',
+        id: user.id,
+        name: user.name,
+        age: user.age,
+        address: user.address,
       },
-      { id: '1' }, // Carry forward data to fast render
+      { id: user.id }, // Carry forward data to fast render
     );
   })
-  .withFastRender(async (props, myContext) => {
+  .withFastRender(async (props, carryForward) => {
     // Fast rendering - dynamic data that can change
     return partialRender(
       {
         stars: 4.5,
         rating: 92,
       },
-      { id: '1' }, // Carry forward data to interactive
+      { id: carryForward.id }, // Carry forward data to interactive
     );
   })
-  .withInteractive((props, refs) => {
-    // Client-side interactivity
+  .withInteractive((props, refs, theme) => {
+    // Client-side interactivity with context
     return {
       render: () => ({
         stars: 4.5,
@@ -181,28 +353,42 @@ Full-stack components that are Jay Stack pages use `PageProps` as the props.
 makeJayStackComponent<MyComponentContract>().withProps<{ userId: string }>();
 ```
 
-#### `.withServerContext(...contextMarkers)`
+#### `.withServices(...serviceMarkers)`
 
-Adds server-side context markers for dependency injection.
+Adds server-side service markers for dependency injection.
 
 ```typescript
-makeJayStackComponent<MyComponentContract>().withServerContext(DatabaseContext, AuthContext);
+import { createJayService } from '@jay-framework/fullstack-component';
+
+const DATABASE_SERVICE = createJayService<Database>('Database');
+const AUTH_SERVICE = createJayService<AuthService>('Auth');
+
+makeJayStackComponent<MyComponentContract>().withServices(DATABASE_SERVICE, AUTH_SERVICE);
 ```
 
-#### `.withClientContext(...contextMarkers)`
+Services are global singletons registered in `src/jay.init.ts`.
+
+#### `.withContexts(...contextMarkers)`
 
 Adds client-side context markers for dependency injection.
 
 ```typescript
-makeJayStackComponent<MyComponentContract>().withClientContext(ThemeContext, UserContext);
+import { createJayContext } from '@jay-framework/runtime';
+
+const ThemeContext = createJayContext<Theme>();
+const UserContext = createJayContext<User>();
+
+makeJayStackComponent<MyComponentContract>().withContexts(ThemeContext, UserContext);
 ```
 
+Contexts are hierarchical and reactive, provided by parent components using `provideContext` or `provideReactiveContext`.
+
 #### `.withLoadParams(loadParams)`
 
 Defines how URL parameters are loaded and converted to additional props,
 on top of the props defined in `withProps`.
 
-The function receives the server contexts declared using `withServerContext`.
+The function receives the services declared using `withServices`.
 
 The function should return a generator that yields arrays of a subtype of `UrlParams`.
 
@@ -211,11 +397,12 @@ interface IdParams extends UrlParams {
   id: string;
 }
 
-makeJayStackComponent<MyComponentContract>().withLoadParams(
-  async function* (contexts): AsyncIterable<IdParams[]> {
-    yield [{ id: '1' }, { id: '2' }];
-  },
-);
+makeJayStackComponent<MyComponentContract>()
+  .withServices(DATABASE_SERVICE)
+  .withLoadParams(async function* (database: Database): AsyncIterable<IdParams[]> {
+    const items = await database.getAllItems();
+    yield items.map((item) => ({ id: item.id }));
+  });
 ```
 
 #### `.withSlowlyRender(slowlyRender)`
@@ -225,37 +412,65 @@ Defines the slow rendering function for semi-static data.
 The function's `props` parameter is a composition of the props from `.withProps`,
 with the subtype of `UrlParams` if using `.withLoadParams`.
 
+After props, the function receives the services declared using `withServices`.
+
 The function should return one of:
 
-- `PartialRender<ViewState, CarryForward>` - for partial rendering
+- `PartialRender<SlowViewState, CarryForward>` - for partial rendering
 - `ServerError5xx` - for server errors
 - `Redirect3xx` - for semi-static redirects
 
+**Type Safety:** TypeScript automatically validates that `partialRender` only receives properties from `SlowViewState` (as defined by `phase: slow` in your contract).
+
 ```typescript
-makeJayStackComponent<MyComponentContract>().withSlowlyRender(async (props, ...contexts) => {
-  return partialRender({ someKey: 'value' }, { carryForwardKey: 'data' });
-});
+makeJayStackComponent<MyComponentContract>()
+  .withServices(DATABASE_SERVICE)
+  .withSlowlyRender(async (props, database: Database) => {
+    const data = await database.getData();
+    return partialRender(
+      {
+        productName: data.name, // ✅ OK if phase: slow
+        // price: data.price,      // ❌ TypeScript error if phase: fast
+      },
+      { carryForwardKey: data.id },
+    );
+  });
 ```
 
 #### `.withFastRender(fastRender)`
 
 Defines the fast rendering function for dynamic data.
 
-The function's `props` parameter is a composition of the props from `.withProps`,
-with the subtype of `UrlParams` if using `.withLoadParams`,
-with the `carryForward` from `.withSlowlyRender` if used.
+The function's first parameter is `props` - a composition of the props from `.withProps`
+with the subtype of `UrlParams` if using `.withLoadParams`.
+
+The second parameter is `carryForward` from `.withSlowlyRender` if used.
+
+After that, the function receives the services declared using `withServices`.
 
 The function should return one of:
 
-- `PartialRender<ViewState, CarryForward>` - for partial rendering
+- `PartialRender<FastViewState, CarryForward>` - for partial rendering
 - `ServerError5xx` - for server errors
 - `ClientError4xx` - for client errors
 - `Redirect3xx` - for dynamic redirects
 
+**Type Safety:** TypeScript automatically validates that `partialRender` only receives properties from `FastViewState` (as defined by `phase: fast` in your contract).
+
 ```typescript
-makeJayStackComponent<MyComponentContract>().withFastRender(async (props, ...contexts) => {
-  return partialRender({ anotherKey: 'value' }, { carryForwardKey: 'data' });
-});
+makeJayStackComponent<MyComponentContract>()
+  .withServices(INVENTORY_SERVICE)
+  .withFastRender(async (props, carryForward, inventory: InventoryService) => {
+    const status = await inventory.getStatus(carryForward.productId);
+    return partialRender(
+      {
+        inStock: status.available > 0, // ✅ OK if phase: fast
+        price: 29.99, // ✅ OK if phase: fast
+        // productName: 'Widget',        // ❌ TypeScript error if phase: slow
+      },
+      { carryForwardKey: 'data' },
+    );
+  });
 ```
 
 #### `.withInteractive(componentConstructor)`
@@ -267,14 +482,18 @@ The function's `props` parameter is a composition of the props from `.withProps`
 with the subtype of `UrlParams` if using `.withLoadParams`,
 with the `carryForward` from `.withFastRender` if used.
 
+After props and refs, the function receives the client-side contexts declared using `withContexts`.
+
 The function is expected to return an object with a reactive `render` function as well as the client component API.
 
 ```typescript
-makeJayStackComponent<MyComponentContract>().withInteractive((props, refs) => {
-  return {
-    render: () => ({ interactiveData: 'value' }),
-  };
-});
+makeJayStackComponent<MyComponentContract>()
+  .withContexts(ThemeContext)
+  .withInteractive((props, refs, theme: Theme) => {
+    return {
+      render: () => ({ interactiveData: 'value', currentTheme: theme.current }),
+    };
+  });
 ```
 
 ## Render Response Builders
@@ -313,6 +532,139 @@ Creates a redirect response.
 return redirect3xx(301, 'http://some.domain.com');
 ```
 
+## Complete Example with Phase Validation
+
+Here's a complete example showing how phase annotations in your contract provide compile-time type safety:
+
+### 1. Define Contract with Phases
+
+**`user-profile.jay-html`**:
+
+```html
+<html>
+  <head>
+    <script type="application/yaml-jay">
+      data:
+        # Static user info - rendered at build time
+        - {tag: userId, dataType: string, phase: slow}
+        - {tag: username, dataType: string, phase: slow}
+        - {tag: bio, dataType: string, phase: slow}
+
+        # Dynamic activity - rendered per request
+        - {tag: lastSeen, dataType: string, phase: fast}
+        - {tag: isOnline, dataType: boolean, phase: fast}
+        - {tag: followerCount, dataType: number, phase: fast}
+    </script>
+  </head>
+  <body>
+    <div>
+      <h1>{username}</h1>
+      <p>{bio}</p>
+      <p>Followers: {followerCount}</p>
+      <span>{isOnline ? 'Online' : 'Last seen: ' + lastSeen}</span>
+    </div>
+  </body>
+</html>
+```
+
+### 2. Generated Types
+
+**`user-profile.jay-html.d.ts`** (auto-generated):
+
+```typescript
+export interface UserProfileViewState {
+  userId: string;
+  username: string;
+  bio: string;
+  lastSeen: string;
+  isOnline: boolean;
+  followerCount: number;
+}
+
+export interface UserProfileElementRefs {}
+
+// Phase-specific types - automatically generated
+export type UserProfileSlowViewState = Pick<UserProfileViewState, 'userId' | 'username' | 'bio'>;
+export type UserProfileFastViewState = Pick<
+  UserProfileViewState,
+  'lastSeen' | 'isOnline' | 'followerCount'
+>;
+export type UserProfileInteractiveViewState = {};
+
+export type UserProfileContract = JayContract<
+  UserProfileViewState,
+  UserProfileElementRefs,
+  UserProfileSlowViewState,
+  UserProfileFastViewState,
+  UserProfileInteractiveViewState
+>;
+```
+
+### 3. Implement with Type Safety
+
+```typescript
+import {
+  makeJayStackComponent,
+  partialRender,
+  createJayService,
+} from '@jay-framework/fullstack-component';
+import { UserProfileContract } from './user-profile.jay-html';
+
+interface UserDatabase {
+  getUser(id: string): Promise<{ id: string; name: string; bio: string }>;
+}
+const USER_DB = createJayService<UserDatabase>('UserDB');
+
+interface ActivityService {
+  getUserActivity(id: string): Promise<{ lastSeen: string; isOnline: boolean; followers: number }>;
+}
+const ACTIVITY_SERVICE = createJayService<ActivityService>('Activity');
+
+export const userProfile = makeJayStackComponent<UserProfileContract>()
+  .withProps()
+  .withServices(USER_DB, ACTIVITY_SERVICE)
+  .withSlowlyRender(async (props, userDb) => {
+    // ✅ TypeScript knows only slow properties are allowed
+    const user = await userDb.getUser('123');
+    return partialRender(
+      {
+        userId: user.id,
+        username: user.name,
+        bio: user.bio,
+        // followerCount: 100,  // ❌ TypeScript Error: Property 'followerCount'
+        //    does not exist in type 'UserProfileSlowViewState'
+      },
+      { userId: user.id },
+    );
+  })
+  .withFastRender(async (props, carryForward, userDb, activityService) => {
+    // ✅ TypeScript knows only fast properties are allowed
+    const activity = await activityService.getUserActivity(carryForward.userId);
+    return partialRender(
+      {
+        lastSeen: activity.lastSeen,
+        isOnline: activity.isOnline,
+        followerCount: activity.followers,
+        // username: 'John',     // ❌ TypeScript Error: Property 'username'
+        //    does not exist in type 'UserProfileFastViewState'
+      },
+      {},
+    );
+  })
+  .withInteractive((props, refs) => {
+    return {
+      render: () => ({}),
+    };
+  });
+```
+
+**Key Benefits:**
+
+- 🔒 **Compile-time guarantees**: TypeScript prevents phase violations before deployment
+- 📊 **Clear separation**: Slow (static) data is visually separated from fast (dynamic) data
+- ⚡ **Optimal performance**: Framework can cache slow data aggressively
+- 🧹 **No boilerplate**: No manual type annotations needed in render functions
+
 ## Advanced Examples
 
 ### A Product Page with URL Parameters
@@ -323,11 +675,12 @@ import {
   PageProps,
   partialRender,
   UrlParams,
+  createJayService,
 } from '@jay-framework/fullstack-component';
 import { render, PageElementRefs } from './page.jay-html';
 import { Props } from '@jay-framework/component';
-import { getProductBySlug, getProducts } from '../../../products-database';
-import { getAvailableUnits } from '../../../inventory-service';
+import { PRODUCTS_DATABASE_SERVICE, ProductsDatabase } from '../../../services/products-database';
+import { INVENTORY_SERVICE, InventoryService } from '../../../services/inventory';
 
 interface ProductPageParams extends UrlParams {
   slug: string;
@@ -342,23 +695,30 @@ interface ProductAndInventoryCarryForward {
   inStock: boolean;
 }
 
-async function* urlLoader(): AsyncIterable<ProductPageParams[]> {
-  const products = await getProducts();
+async function* urlLoader(productsDb: ProductsDatabase): AsyncIterable<ProductPageParams[]> {
+  const products = await productsDb.getAllProducts();
   yield products.map(({ slug }) => ({ slug }));
 }
 
-async function renderSlowlyChanging(props: PageProps & ProductPageParams) {
-  const { name, sku, price, id } = await getProductBySlug(props.slug);
+async function renderSlowlyChanging(
+  props: PageProps & ProductPageParams,
+  productsDb: ProductsDatabase,
+) {
+  const { name, sku, price, id } = await productsDb.getProductBySlug(props.slug);
   return partialRender({ name, sku, price, id }, { productId: id });
 }
 
-async function renderFastChanging(props: PageProps & ProductPageParams & ProductsCarryForward) {
-  const availableProducts = await getAvailableUnits(props.productId);
+async function renderFastChanging(
+  props: PageProps & ProductPageParams,
+  carryForward: ProductsCarryForward,
+  inventory: InventoryService,
+) {
+  const availableProducts = await inventory.getAvailableUnits(carryForward.productId);
   const inStock = availableProducts > 0;
   return partialRender(
     { inStock },
     {
-      productId: props.productId,
+      productId: carryForward.productId,
       inStock,
     },
   );
@@ -375,6 +735,7 @@ function ProductsPageConstructor(
 
 export const page = makeJayStackComponent<typeof render>()
   .withProps<PageProps>()
+  .withServices(PRODUCTS_DATABASE_SERVICE, INVENTORY_SERVICE)
   .withLoadParams(urlLoader)
   .withSlowlyRender(renderSlowlyChanging)
   .withFastRender(renderFastChanging)

package/dist/index.d.ts

@@ -1,7 +1,35 @@
 import { JayComponentCore, ContextMarkers, ComponentConstructor } from '@jay-framework/component';
-import { JayContract, ExtractViewState, ExtractRefs } from '@jay-framework/runtime';
+import { JayContract, ExtractRefs, ExtractSlowViewState, ExtractFastViewState, ExtractInteractiveViewState } from '@jay-framework/runtime';
+export { ExtractFastViewState, ExtractInteractiveViewState, ExtractRefs, ExtractSlowViewState, ExtractViewState, JayContract } from '@jay-framework/runtime';
 import { Getter, Setter } from '@jay-framework/reactive';
 
+/**
+ * A type-safe marker for identifying a service.
+ * Similar to ContextMarker but for server-side services.
+ */
+interface ServiceMarker<ServiceType> {
+}
+/**
+ * Creates a service marker used to register and retrieve services.
+ *
+ * @param name - Optional name for the service (used in error messages)
+ *
+ * @example
+ * ```typescript
+ * export interface DatabaseService {
+ *   query<T>(sql: string): Promise<T[]>;
+ * }
+ *
+ * export const DATABASE_SERVICE = createJayService<DatabaseService>('DatabaseService');
+ * ```
+ */
+declare function createJayService<ServiceType = unknown>(name?: string): ServiceMarker<ServiceType>;
+/**
+ * Type helper for extracting service types from an array of markers.
+ */
+type ServiceMarkers<T extends any[]> = {
+    [K in keyof T]: ServiceMarker<T[K]>;
+};
 interface PageProps {
     language: string;
     url: string;
@@ -22,190 +50,113 @@ interface Redirect3xx {
 }
 interface PartialRender<ViewState extends object, CarryForward> {
     kind: 'PartialRender';
-    rendered: Partial<ViewState>;
+    rendered: ViewState;
     carryForward: CarryForward;
 }
 type SlowlyRenderResult<ViewState extends object, CarryForward> = PartialRender<ViewState, CarryForward> | ServerError5xx | ClientError4xx | Redirect3xx;
 type AnySlowlyRenderResult = SlowlyRenderResult<object, object>;
 type FastRenderResult<ViewState extends object, CarryForward> = PartialRender<ViewState, CarryForward> | ServerError5xx | ClientError4xx | Redirect3xx;
 type AnyFastRenderResult = FastRenderResult<object, object>;
-type LoadParams<ServerContexts, Params extends UrlParams> = (contexts: ServerContexts) => AsyncIterable<Params[]>;
-type RenderSlowly<ServerContexts extends Array<object>, PropsT extends object, StaticViewState extends object, SlowlyCarryForward> = (props: PropsT, ...contexts: ServerContexts) => Promise<SlowlyRenderResult<StaticViewState, SlowlyCarryForward>>;
-type RenderFast<ServerContexts extends Array<object>, PropsT extends object, DynamicViewState extends object, FastCarryForward> = (props: PropsT, ...contexts: ServerContexts) => Promise<FastRenderResult<DynamicViewState, FastCarryForward>>;
-interface JayStackComponentDefinition<StaticViewState extends object, ViewState extends object, Refs extends object, ServerContexts extends Array<any>, ClientContexts extends Array<any>, PropsT extends object, Params extends UrlParams, CompCore extends JayComponentCore<PropsT, ViewState>> {
-    serverContexts: ContextMarkers<ServerContexts>;
-    clientContexts: ContextMarkers<ClientContexts>;
-    loadParams: LoadParams<ServerContexts, Params>;
-    slowlyRender: RenderSlowly<ServerContexts, PropsT, StaticViewState, any>;
-    fastRender: RenderFast<ServerContexts, PropsT, ViewState, any>;
-    comp: ComponentConstructor<PropsT, Refs, ViewState, ClientContexts, CompCore>;
+type LoadParams<Services, Params extends UrlParams> = (contexts: Services) => AsyncIterable<Params[]>;
+type RenderSlowly<Services extends Array<object>, PropsT extends object, SlowViewState extends object, SlowlyCarryForward> = (props: PropsT, ...services: Services) => Promise<SlowlyRenderResult<SlowViewState, SlowlyCarryForward>>;
+type RenderFast<Services extends Array<object>, PropsT extends object, FastViewState extends object, FastCarryForward> = (props: PropsT, ...services: Services) => Promise<FastRenderResult<FastViewState, FastCarryForward>>;
+interface JayStackComponentDefinition<Refs extends object, SlowVS extends object, FastVS extends object, InteractiveVS extends object, Services extends Array<any>, Contexts extends Array<any>, PropsT extends object, Params extends UrlParams, CompCore extends JayComponentCore<PropsT, InteractiveVS>> {
+    services: ServiceMarkers<Services>;
+    contexts: ContextMarkers<Contexts>;
+    loadParams: LoadParams<Services, Params>;
+    slowlyRender: RenderSlowly<Services, PropsT, SlowVS, any>;
+    fastRender: RenderFast<Services, PropsT, FastVS, any>;
+    comp: ComponentConstructor<PropsT, Refs, InteractiveVS, Contexts, CompCore>;
 }
-type AnyJayStackComponentDefinition = JayStackComponentDefinition<object, object, object, object[], object[], object, UrlParams, any>;
+type AnyJayStackComponentDefinition = JayStackComponentDefinition<object, object, object, object, object[], object[], object, UrlParams, any>;
 
 declare function serverError5xx(status: number): ServerError5xx;
 declare function clientError4xx(status: number): ClientError4xx;
 declare function notFound(): ClientError4xx;
 declare function redirect3xx(status: number, location: string): Redirect3xx;
-declare function partialRender<ViewState extends object, CarryForward>(rendered: Partial<ViewState>, carryForward: CarryForward): PartialRender<ViewState, CarryForward>;
+declare function partialRender<ViewState extends object, CarryForward>(rendered: ViewState, carryForward: CarryForward): PartialRender<ViewState, CarryForward>;
 
-type BuilderStates = 'Props' | 'ServerContexts' | 'ClientContexts' | 'UrlLoader' | 'SlowlyRender' | 'FastRender' | 'InteractiveRender' | 'Done';
+type BuilderStates = 'Props' | 'Services' | 'Contexts' | 'UrlLoader' | 'SlowlyRender' | 'FastRender' | 'InteractiveRender' | 'Done';
 type Signals<T extends object> = {
     [K in keyof T]: K extends string ? [Getter<T[K]>, Setter<T[K]>] : T[K];
 };
-type Builder<State extends BuilderStates, StaticViewState extends object, ViewState extends object, Refs extends object, ServerContexts extends Array<any>, ClientContexts extends Array<any>, PropsT extends object, Params extends UrlParams, CompCore extends JayComponentCore<PropsT, ViewState>> = State extends 'Props' ? JayStackComponentDefinition<StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore> & {
-    withProps<NewPropsT extends object>(): Builder<'ServerContexts', StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, NewPropsT, Params, JayComponentCore<NewPropsT, ViewState>>;
-} : State extends 'ServerContexts' ? JayStackComponentDefinition<StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore> & {
-    withServerContext<NewServerContexts extends Array<any>>(...contextMarkers: ContextMarkers<NewServerContexts>): Builder<'ClientContexts', StaticViewState, ViewState, Refs, NewServerContexts, ClientContexts, PropsT, Params, CompCore>;
-    withClientContext<NewClientContexts extends Array<any>>(...contextMarkers: ContextMarkers<NewClientContexts>): Builder<'UrlLoader', StaticViewState, ViewState, Refs, ServerContexts, NewClientContexts, PropsT, Params, CompCore>;
-    withLoadParams<NewParams extends UrlParams>(loadParams: LoadParams<ServerContexts, NewParams>): Builder<'SlowlyRender', StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT & NewParams, NewParams, CompCore>;
-    withSlowlyRender<NewStaticViewState extends Partial<ViewState>, NewCarryForward extends object>(slowlyRender: RenderSlowly<ServerContexts, PropsT, NewStaticViewState, NewCarryForward>): Builder<'FastRender', NewStaticViewState, Partial<ViewState> & Omit<ViewState, keyof NewStaticViewState>, Refs, [
+type Builder<State extends BuilderStates, Refs extends object, SlowVS extends object, FastVS extends object, InteractiveVS extends object, Services extends Array<any>, Contexts extends Array<any>, PropsT extends object, Params extends UrlParams, CompCore extends JayComponentCore<PropsT, InteractiveVS>> = State extends 'Props' ? JayStackComponentDefinition<Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore> & {
+    withProps<NewPropsT extends object>(): Builder<'Services', Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, NewPropsT, Params, JayComponentCore<NewPropsT, InteractiveVS>>;
+} : State extends 'Services' ? JayStackComponentDefinition<Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore> & {
+    withServices<NewServices extends Array<any>>(...serviceMarkers: ServiceMarkers<NewServices>): Builder<'Contexts', Refs, SlowVS, FastVS, InteractiveVS, NewServices, Contexts, PropsT, Params, CompCore>;
+    withContexts<NewContexts extends Array<any>>(...contextMarkers: ContextMarkers<NewContexts>): Builder<'UrlLoader', Refs, SlowVS, FastVS, InteractiveVS, Services, NewContexts, PropsT, Params, CompCore>;
+    withLoadParams<NewParams extends UrlParams>(loadParams: LoadParams<Services, NewParams>): Builder<'SlowlyRender', Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT & NewParams, NewParams, CompCore>;
+    withSlowlyRender<NewCarryForward extends object>(slowlyRender: RenderSlowly<Services, PropsT, SlowVS, NewCarryForward>): Builder<'FastRender', Refs, SlowVS, FastVS, InteractiveVS, [
         NewCarryForward,
-        ...ServerContexts
-    ], ClientContexts, PropsT, Params, JayComponentCore<PropsT, Partial<ViewState> & Omit<ViewState, keyof NewStaticViewState>>>;
-    withFastRender<NewCarryForward extends object>(fastRender: RenderFast<ServerContexts, PropsT, ViewState, NewCarryForward>): Builder<'InteractiveRender', StaticViewState, Partial<ViewState>, Refs, ServerContexts, [
+        ...Services
+    ], Contexts, PropsT, Params, JayComponentCore<PropsT, InteractiveVS>>;
+    withFastRender<NewCarryForward extends object>(fastRender: RenderFast<Services, PropsT, FastVS, NewCarryForward>): Builder<'InteractiveRender', Refs, SlowVS, FastVS, InteractiveVS, Services, [
         Signals<NewCarryForward>,
-        ...ClientContexts
-    ], PropsT, Params, JayComponentCore<PropsT, Partial<ViewState>>>;
-    withInteractive(comp: ComponentConstructor<PropsT, Refs, ViewState, ClientContexts, CompCore>): Builder<'Done', StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore>;
-} : State extends 'ClientContexts' ? JayStackComponentDefinition<StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore> & {
-    withClientContext<NewClientContexts extends Array<any>>(...contextMarkers: ContextMarkers<NewClientContexts>): Builder<'UrlLoader', StaticViewState, ViewState, Refs, ServerContexts, NewClientContexts, PropsT, Params, CompCore>;
-    withLoadParams<NewParams extends UrlParams>(loadParams: LoadParams<ServerContexts, NewParams>): Builder<'SlowlyRender', StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT & NewParams, NewParams, CompCore>;
-    withSlowlyRender<NewStaticViewState extends Partial<ViewState>, NewCarryForward extends object>(slowlyRender: RenderSlowly<ServerContexts, PropsT, NewStaticViewState, NewCarryForward>): Builder<'FastRender', NewStaticViewState, Partial<ViewState> & Omit<ViewState, keyof NewStaticViewState>, Refs, [
+        ...Contexts
+    ], PropsT, Params, JayComponentCore<PropsT, InteractiveVS>>;
+    withInteractive(comp: ComponentConstructor<PropsT, Refs, InteractiveVS, Contexts, CompCore>): Builder<'Done', Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore>;
+} : State extends 'Contexts' ? JayStackComponentDefinition<Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore> & {
+    withContexts<NewContexts extends Array<any>>(...contextMarkers: ContextMarkers<NewContexts>): Builder<'UrlLoader', Refs, SlowVS, FastVS, InteractiveVS, Services, NewContexts, PropsT, Params, CompCore>;
+    withLoadParams<NewParams extends UrlParams>(loadParams: LoadParams<Services, NewParams>): Builder<'SlowlyRender', Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT & NewParams, NewParams, CompCore>;
+    withSlowlyRender<NewCarryForward extends object>(slowlyRender: RenderSlowly<Services, PropsT, SlowVS, NewCarryForward>): Builder<'FastRender', Refs, SlowVS, FastVS, InteractiveVS, [
         NewCarryForward,
-        ...ServerContexts
-    ], ClientContexts, PropsT, Params, JayComponentCore<PropsT, Partial<ViewState> & Omit<ViewState, keyof NewStaticViewState>>>;
-    withFastRender<NewCarryForward extends object>(fastRender: RenderFast<ServerContexts, PropsT, ViewState, NewCarryForward>): Builder<'InteractiveRender', StaticViewState, Partial<ViewState>, Refs, ServerContexts, [
+        ...Services
+    ], Contexts, PropsT, Params, JayComponentCore<PropsT, InteractiveVS>>;
+    withFastRender<NewCarryForward extends object>(fastRender: RenderFast<Services, PropsT, FastVS, NewCarryForward>): Builder<'InteractiveRender', Refs, SlowVS, FastVS, InteractiveVS, Services, [
         Signals<NewCarryForward>,
-        ...ClientContexts
-    ], PropsT, Params, JayComponentCore<PropsT, Partial<ViewState>>>;
-    withInteractive(comp: ComponentConstructor<PropsT, Refs, ViewState, ClientContexts, CompCore>): Builder<'Done', StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore>;
-} : State extends 'UrlLoader' ? JayStackComponentDefinition<StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore> & {
-    withLoadParams<NewParams extends UrlParams>(loadParams: LoadParams<ServerContexts, NewParams>): Builder<'SlowlyRender', StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT & NewParams, NewParams, CompCore>;
-    withSlowlyRender<NewStaticViewState extends Partial<ViewState>, NewCarryForward extends object>(slowlyRender: RenderSlowly<ServerContexts, PropsT, NewStaticViewState, NewCarryForward>): Builder<'FastRender', NewStaticViewState, Partial<ViewState> & Omit<ViewState, keyof NewStaticViewState>, Refs, [
+        ...Contexts
+    ], PropsT, Params, JayComponentCore<PropsT, InteractiveVS>>;
+    withInteractive(comp: ComponentConstructor<PropsT, Refs, InteractiveVS, Contexts, CompCore>): Builder<'Done', Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore>;
+} : State extends 'UrlLoader' ? JayStackComponentDefinition<Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore> & {
+    withLoadParams<NewParams extends UrlParams>(loadParams: LoadParams<Services, NewParams>): Builder<'SlowlyRender', Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT & NewParams, NewParams, CompCore>;
+    withSlowlyRender<NewCarryForward extends object>(slowlyRender: RenderSlowly<Services, PropsT, SlowVS, NewCarryForward>): Builder<'FastRender', Refs, SlowVS, FastVS, InteractiveVS, [
         NewCarryForward,
-        ...ServerContexts
-    ], ClientContexts, PropsT, Params, JayComponentCore<PropsT, Partial<ViewState> & Omit<ViewState, keyof NewStaticViewState>>>;
-    withFastRender<NewCarryForward extends object>(fastRender: RenderFast<ServerContexts, PropsT, ViewState, NewCarryForward>): Builder<'InteractiveRender', StaticViewState, Partial<ViewState>, Refs, ServerContexts, [
+        ...Services
+    ], Contexts, PropsT, Params, JayComponentCore<PropsT, InteractiveVS>>;
+    withFastRender<NewCarryForward extends object>(fastRender: RenderFast<Services, PropsT, FastVS, NewCarryForward>): Builder<'InteractiveRender', Refs, SlowVS, FastVS, InteractiveVS, Services, [
         Signals<NewCarryForward>,
-        ...ClientContexts
-    ], PropsT, Params, JayComponentCore<PropsT, Partial<ViewState>>>;
-    withInteractive(comp: ComponentConstructor<PropsT, Refs, ViewState, ClientContexts, CompCore>): Builder<'Done', StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore>;
-} : State extends 'SlowlyRender' ? JayStackComponentDefinition<StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore> & {
-    withSlowlyRender<NewStaticViewState extends Partial<ViewState>, NewCarryForward extends object>(slowlyRender: RenderSlowly<ServerContexts, PropsT, NewStaticViewState, NewCarryForward>): Builder<'FastRender', NewStaticViewState, Partial<ViewState> & Omit<ViewState, keyof NewStaticViewState>, Refs, [
+        ...Contexts
+    ], PropsT, Params, JayComponentCore<PropsT, InteractiveVS>>;
+    withInteractive(comp: ComponentConstructor<PropsT, Refs, InteractiveVS, Contexts, CompCore>): Builder<'Done', Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore>;
+} : State extends 'SlowlyRender' ? JayStackComponentDefinition<Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore> & {
+    withSlowlyRender<NewCarryForward extends object>(slowlyRender: RenderSlowly<Services, PropsT, SlowVS, NewCarryForward>): Builder<'FastRender', Refs, SlowVS, FastVS, InteractiveVS, [
         NewCarryForward,
-        ...ServerContexts
-    ], ClientContexts, PropsT, Params, JayComponentCore<PropsT, Partial<ViewState> & Omit<ViewState, keyof NewStaticViewState>>>;
-    withFastRender<NewCarryForward extends object>(fastRender: RenderFast<ServerContexts, PropsT, ViewState, NewCarryForward>): Builder<'InteractiveRender', StaticViewState, Partial<ViewState>, Refs, ServerContexts, [
+        ...Services
+    ], Contexts, PropsT, Params, JayComponentCore<PropsT, InteractiveVS>>;
+    withFastRender<NewCarryForward extends object>(fastRender: RenderFast<Services, PropsT, FastVS, NewCarryForward>): Builder<'InteractiveRender', Refs, SlowVS, FastVS, InteractiveVS, Services, [
         Signals<NewCarryForward>,
-        ...ClientContexts
-    ], PropsT, Params, JayComponentCore<PropsT, Partial<ViewState>>>;
-    withInteractive(comp: ComponentConstructor<PropsT, Refs, ViewState, ClientContexts, CompCore>): Builder<'Done', StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore>;
-} : State extends 'FastRender' ? JayStackComponentDefinition<StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore> & {
-    withFastRender<NewCarryForward extends object>(fastRender: RenderFast<ServerContexts, PropsT, ViewState, NewCarryForward>): Builder<'InteractiveRender', StaticViewState, Partial<ViewState>, Refs, ServerContexts, [
+        ...Contexts
+    ], PropsT, Params, JayComponentCore<PropsT, InteractiveVS>>;
+    withInteractive(comp: ComponentConstructor<PropsT, Refs, InteractiveVS, Contexts, CompCore>): Builder<'Done', Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore>;
+} : State extends 'FastRender' ? JayStackComponentDefinition<Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore> & {
+    withFastRender<NewCarryForward extends object>(fastRender: RenderFast<Services, PropsT, FastVS, NewCarryForward>): Builder<'InteractiveRender', Refs, SlowVS, FastVS, InteractiveVS, Services, [
         Signals<NewCarryForward>,
-        ...ClientContexts
-    ], PropsT, Params, JayComponentCore<PropsT, Partial<ViewState>>>;
-    withInteractive(comp: ComponentConstructor<PropsT, Refs, ViewState, ClientContexts, CompCore>): Builder<'Done', StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore>;
-} : State extends 'InteractiveRender' ? JayStackComponentDefinition<StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore> & {
-    withInteractive(comp: ComponentConstructor<PropsT, Refs, ViewState, ClientContexts, CompCore>): Builder<'Done', StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore>;
-} : JayStackComponentDefinition<StaticViewState, ViewState, Refs, ServerContexts, ClientContexts, PropsT, Params, CompCore>;
-declare function makeJayStackComponent<Render extends JayContract<any, any>>(): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, [], [], {}, {}, JayComponentCore<object, ExtractViewState<Render>>> & {
-    withProps<NewPropsT extends object>(): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, [], [], NewPropsT, {}, JayComponentCore<NewPropsT, ExtractViewState<Render>>> & {
-        withServerContext<NewServerContexts extends any[]>(...contextMarkers: ContextMarkers<NewServerContexts>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, NewServerContexts, [], NewPropsT, {}, JayComponentCore<NewPropsT, ExtractViewState<Render>>> & {
-            withClientContext<NewClientContexts extends any[]>(...contextMarkers: ContextMarkers<NewClientContexts>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, NewServerContexts, NewClientContexts, NewPropsT, {}, JayComponentCore<NewPropsT, ExtractViewState<Render>>> & {
-                withLoadParams<NewParams extends UrlParams>(loadParams: LoadParams<NewServerContexts, NewParams>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, NewServerContexts, NewClientContexts, NewPropsT & NewParams, NewParams, JayComponentCore<NewPropsT, ExtractViewState<Render>>> & {
-                    withSlowlyRender<NewStaticViewState extends Partial<ExtractViewState<Render>>, NewCarryForward extends object>(slowlyRender: RenderSlowly<NewServerContexts, NewPropsT & NewParams, NewStaticViewState, NewCarryForward>): JayStackComponentDefinition<NewStaticViewState, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>, ExtractRefs<Render>, [NewCarryForward, ...NewServerContexts], NewClientContexts, NewPropsT & NewParams, NewParams, JayComponentCore<NewPropsT & NewParams, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>>> & {
-                        withFastRender<NewCarryForward_1 extends object>(fastRender: RenderFast<[NewCarryForward, ...NewServerContexts], NewPropsT & NewParams, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>, NewCarryForward_1>): JayStackComponentDefinition<NewStaticViewState, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>>, ExtractRefs<Render>, [NewCarryForward, ...NewServerContexts], [Signals<NewCarryForward_1>, ...NewClientContexts], NewPropsT & NewParams, NewParams, JayComponentCore<NewPropsT & NewParams, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>>>> & {
-                            withInteractive(comp: ComponentConstructor<NewPropsT & NewParams, ExtractRefs<Render>, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>>, [Signals<NewCarryForward_1>, ...NewClientContexts], JayComponentCore<NewPropsT & NewParams, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>>>>): JayStackComponentDefinition<NewStaticViewState, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>>, ExtractRefs<Render>, [NewCarryForward, ...NewServerContexts], [Signals<NewCarryForward_1>, ...NewClientContexts], NewPropsT & NewParams, NewParams, JayComponentCore<NewPropsT & NewParams, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>>>>;
-                        };
-                        withInteractive(comp: ComponentConstructor<NewPropsT & NewParams, ExtractRefs<Render>, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>, NewClientContexts, JayComponentCore<NewPropsT & NewParams, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>>>): JayStackComponentDefinition<NewStaticViewState, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>, ExtractRefs<Render>, [NewCarryForward, ...NewServerContexts], NewClientContexts, NewPropsT & NewParams, NewParams, JayComponentCore<NewPropsT & NewParams, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState>>>;
-                    };
-                    withFastRender<NewCarryForward_2 extends object>(fastRender: RenderFast<NewServerContexts, NewPropsT & NewParams, ExtractViewState<Render>, NewCarryForward_2>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, NewServerContexts, [Signals<NewCarryForward_2>, ...NewClientContexts], NewPropsT & NewParams, NewParams, JayComponentCore<NewPropsT & NewParams, Partial<ExtractViewState<Render>>>> & {
-                        withInteractive(comp: ComponentConstructor<NewPropsT & NewParams, ExtractRefs<Render>, Partial<ExtractViewState<Render>>, [Signals<NewCarryForward_2>, ...NewClientContexts], JayComponentCore<NewPropsT & NewParams, Partial<ExtractViewState<Render>>>>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, NewServerContexts, [Signals<NewCarryForward_2>, ...NewClientContexts], NewPropsT & NewParams, NewParams, JayComponentCore<NewPropsT & NewParams, Partial<ExtractViewState<Render>>>>;
-                    };
-                    withInteractive(comp: ComponentConstructor<NewPropsT & NewParams, ExtractRefs<Render>, ExtractViewState<Render>, NewClientContexts, JayComponentCore<NewPropsT, ExtractViewState<Render>>>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, NewServerContexts, NewClientContexts, NewPropsT & NewParams, NewParams, JayComponentCore<NewPropsT, ExtractViewState<Render>>>;
-                };
-                withSlowlyRender<NewStaticViewState_1 extends Partial<ExtractViewState<Render>>, NewCarryForward_3 extends object>(slowlyRender: RenderSlowly<NewServerContexts, NewPropsT, NewStaticViewState_1, NewCarryForward_3>): JayStackComponentDefinition<NewStaticViewState_1, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>, ExtractRefs<Render>, [NewCarryForward_3, ...NewServerContexts], NewClientContexts, NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>>> & {
-                    withFastRender<NewCarryForward_4 extends object>(fastRender: RenderFast<[NewCarryForward_3, ...NewServerContexts], NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>, NewCarryForward_4>): JayStackComponentDefinition<NewStaticViewState_1, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>>, ExtractRefs<Render>, [NewCarryForward_3, ...NewServerContexts], [Signals<NewCarryForward_4>, ...NewClientContexts], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>>>> & {
-                        withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>>, [Signals<NewCarryForward_4>, ...NewClientContexts], JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>>>>): JayStackComponentDefinition<NewStaticViewState_1, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>>, ExtractRefs<Render>, [NewCarryForward_3, ...NewServerContexts], [Signals<NewCarryForward_4>, ...NewClientContexts], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>>>>;
-                    };
-                    withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>, NewClientContexts, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>>>): JayStackComponentDefinition<NewStaticViewState_1, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>, ExtractRefs<Render>, [NewCarryForward_3, ...NewServerContexts], NewClientContexts, NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_1>>>;
-                };
-                withFastRender<NewCarryForward_5 extends object>(fastRender: RenderFast<NewServerContexts, NewPropsT, ExtractViewState<Render>, NewCarryForward_5>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, NewServerContexts, [Signals<NewCarryForward_5>, ...NewClientContexts], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>> & {
-                    withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<ExtractViewState<Render>>, [Signals<NewCarryForward_5>, ...NewClientContexts], JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, NewServerContexts, [Signals<NewCarryForward_5>, ...NewClientContexts], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>>;
-                };
-                withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, ExtractViewState<Render>, NewClientContexts, JayComponentCore<NewPropsT, ExtractViewState<Render>>>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, NewServerContexts, NewClientContexts, NewPropsT, {}, JayComponentCore<NewPropsT, ExtractViewState<Render>>>;
-            };
-            withLoadParams<NewParams_1 extends UrlParams>(loadParams: LoadParams<NewServerContexts, NewParams_1>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, NewServerContexts, [], NewPropsT & NewParams_1, NewParams_1, JayComponentCore<NewPropsT, ExtractViewState<Render>>> & {
-                withSlowlyRender<NewStaticViewState_2 extends Partial<ExtractViewState<Render>>, NewCarryForward_6 extends object>(slowlyRender: RenderSlowly<NewServerContexts, NewPropsT & NewParams_1, NewStaticViewState_2, NewCarryForward_6>): JayStackComponentDefinition<NewStaticViewState_2, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>, ExtractRefs<Render>, [NewCarryForward_6, ...NewServerContexts], [], NewPropsT & NewParams_1, NewParams_1, JayComponentCore<NewPropsT & NewParams_1, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>>> & {
-                    withFastRender<NewCarryForward_7 extends object>(fastRender: RenderFast<[NewCarryForward_6, ...NewServerContexts], NewPropsT & NewParams_1, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>, NewCarryForward_7>): JayStackComponentDefinition<NewStaticViewState_2, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>>, ExtractRefs<Render>, [NewCarryForward_6, ...NewServerContexts], [Signals<NewCarryForward_7>], NewPropsT & NewParams_1, NewParams_1, JayComponentCore<NewPropsT & NewParams_1, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>>>> & {
-                        withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_1, ExtractRefs<Render>, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>>, [Signals<NewCarryForward_7>], JayComponentCore<NewPropsT & NewParams_1, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>>>>): JayStackComponentDefinition<NewStaticViewState_2, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>>, ExtractRefs<Render>, [NewCarryForward_6, ...NewServerContexts], [Signals<NewCarryForward_7>], NewPropsT & NewParams_1, NewParams_1, JayComponentCore<NewPropsT & NewParams_1, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>>>>;
-                    };
-                    withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_1, ExtractRefs<Render>, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>, [], JayComponentCore<NewPropsT & NewParams_1, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>>>): JayStackComponentDefinition<NewStaticViewState_2, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>, ExtractRefs<Render>, [NewCarryForward_6, ...NewServerContexts], [], NewPropsT & NewParams_1, NewParams_1, JayComponentCore<NewPropsT & NewParams_1, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_2>>>;
-                };
-                withFastRender<NewCarryForward_8 extends object>(fastRender: RenderFast<NewServerContexts, NewPropsT & NewParams_1, ExtractViewState<Render>, NewCarryForward_8>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, NewServerContexts, [Signals<NewCarryForward_8>], NewPropsT & NewParams_1, NewParams_1, JayComponentCore<NewPropsT & NewParams_1, Partial<ExtractViewState<Render>>>> & {
-                    withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_1, ExtractRefs<Render>, Partial<ExtractViewState<Render>>, [Signals<NewCarryForward_8>], JayComponentCore<NewPropsT & NewParams_1, Partial<ExtractViewState<Render>>>>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, NewServerContexts, [Signals<NewCarryForward_8>], NewPropsT & NewParams_1, NewParams_1, JayComponentCore<NewPropsT & NewParams_1, Partial<ExtractViewState<Render>>>>;
-                };
-                withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_1, ExtractRefs<Render>, ExtractViewState<Render>, [], JayComponentCore<NewPropsT, ExtractViewState<Render>>>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, NewServerContexts, [], NewPropsT & NewParams_1, NewParams_1, JayComponentCore<NewPropsT, ExtractViewState<Render>>>;
-            };
-            withSlowlyRender<NewStaticViewState_3 extends Partial<ExtractViewState<Render>>, NewCarryForward_9 extends object>(slowlyRender: RenderSlowly<NewServerContexts, NewPropsT, NewStaticViewState_3, NewCarryForward_9>): JayStackComponentDefinition<NewStaticViewState_3, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>, ExtractRefs<Render>, [NewCarryForward_9, ...NewServerContexts], [], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>>> & {
-                withFastRender<NewCarryForward_10 extends object>(fastRender: RenderFast<[NewCarryForward_9, ...NewServerContexts], NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>, NewCarryForward_10>): JayStackComponentDefinition<NewStaticViewState_3, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>>, ExtractRefs<Render>, [NewCarryForward_9, ...NewServerContexts], [Signals<NewCarryForward_10>], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>>>> & {
-                    withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>>, [Signals<NewCarryForward_10>], JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>>>>): JayStackComponentDefinition<NewStaticViewState_3, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>>, ExtractRefs<Render>, [NewCarryForward_9, ...NewServerContexts], [Signals<NewCarryForward_10>], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>>>>;
-                };
-                withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>, [], JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>>>): JayStackComponentDefinition<NewStaticViewState_3, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>, ExtractRefs<Render>, [NewCarryForward_9, ...NewServerContexts], [], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_3>>>;
-            };
-            withFastRender<NewCarryForward_11 extends object>(fastRender: RenderFast<NewServerContexts, NewPropsT, ExtractViewState<Render>, NewCarryForward_11>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, NewServerContexts, [Signals<NewCarryForward_11>], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>> & {
-                withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<ExtractViewState<Render>>, [Signals<NewCarryForward_11>], JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, NewServerContexts, [Signals<NewCarryForward_11>], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>>;
-            };
-            withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, ExtractViewState<Render>, [], JayComponentCore<NewPropsT, ExtractViewState<Render>>>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, NewServerContexts, [], NewPropsT, {}, JayComponentCore<NewPropsT, ExtractViewState<Render>>>;
-        };
-        withClientContext<NewClientContexts_1 extends any[]>(...contextMarkers: ContextMarkers<NewClientContexts_1>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, [], NewClientContexts_1, NewPropsT, {}, JayComponentCore<NewPropsT, ExtractViewState<Render>>> & {
-            withLoadParams<NewParams_2 extends UrlParams>(loadParams: LoadParams<[], NewParams_2>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, [], NewClientContexts_1, NewPropsT & NewParams_2, NewParams_2, JayComponentCore<NewPropsT, ExtractViewState<Render>>> & {
-                withSlowlyRender<NewStaticViewState_4 extends Partial<ExtractViewState<Render>>, NewCarryForward_12 extends object>(slowlyRender: RenderSlowly<[], NewPropsT & NewParams_2, NewStaticViewState_4, NewCarryForward_12>): JayStackComponentDefinition<NewStaticViewState_4, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>, ExtractRefs<Render>, [NewCarryForward_12], NewClientContexts_1, NewPropsT & NewParams_2, NewParams_2, JayComponentCore<NewPropsT & NewParams_2, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>>> & {
-                    withFastRender<NewCarryForward_13 extends object>(fastRender: RenderFast<[NewCarryForward_12], NewPropsT & NewParams_2, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>, NewCarryForward_13>): JayStackComponentDefinition<NewStaticViewState_4, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>>, ExtractRefs<Render>, [NewCarryForward_12], [Signals<NewCarryForward_13>, ...NewClientContexts_1], NewPropsT & NewParams_2, NewParams_2, JayComponentCore<NewPropsT & NewParams_2, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>>>> & {
-                        withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_2, ExtractRefs<Render>, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>>, [Signals<NewCarryForward_13>, ...NewClientContexts_1], JayComponentCore<NewPropsT & NewParams_2, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>>>>): JayStackComponentDefinition<NewStaticViewState_4, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>>, ExtractRefs<Render>, [NewCarryForward_12], [Signals<NewCarryForward_13>, ...NewClientContexts_1], NewPropsT & NewParams_2, NewParams_2, JayComponentCore<NewPropsT & NewParams_2, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>>>>;
-                    };
-                    withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_2, ExtractRefs<Render>, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>, NewClientContexts_1, JayComponentCore<NewPropsT & NewParams_2, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>>>): JayStackComponentDefinition<NewStaticViewState_4, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>, ExtractRefs<Render>, [NewCarryForward_12], NewClientContexts_1, NewPropsT & NewParams_2, NewParams_2, JayComponentCore<NewPropsT & NewParams_2, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_4>>>;
-                };
-                withFastRender<NewCarryForward_14 extends object>(fastRender: RenderFast<[], NewPropsT & NewParams_2, ExtractViewState<Render>, NewCarryForward_14>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, [], [Signals<NewCarryForward_14>, ...NewClientContexts_1], NewPropsT & NewParams_2, NewParams_2, JayComponentCore<NewPropsT & NewParams_2, Partial<ExtractViewState<Render>>>> & {
-                    withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_2, ExtractRefs<Render>, Partial<ExtractViewState<Render>>, [Signals<NewCarryForward_14>, ...NewClientContexts_1], JayComponentCore<NewPropsT & NewParams_2, Partial<ExtractViewState<Render>>>>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, [], [Signals<NewCarryForward_14>, ...NewClientContexts_1], NewPropsT & NewParams_2, NewParams_2, JayComponentCore<NewPropsT & NewParams_2, Partial<ExtractViewState<Render>>>>;
-                };
-                withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_2, ExtractRefs<Render>, ExtractViewState<Render>, NewClientContexts_1, JayComponentCore<NewPropsT, ExtractViewState<Render>>>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, [], NewClientContexts_1, NewPropsT & NewParams_2, NewParams_2, JayComponentCore<NewPropsT, ExtractViewState<Render>>>;
-            };
-            withSlowlyRender<NewStaticViewState_5 extends Partial<ExtractViewState<Render>>, NewCarryForward_15 extends object>(slowlyRender: RenderSlowly<[], NewPropsT, NewStaticViewState_5, NewCarryForward_15>): JayStackComponentDefinition<NewStaticViewState_5, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>, ExtractRefs<Render>, [NewCarryForward_15], NewClientContexts_1, NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>>> & {
-                withFastRender<NewCarryForward_16 extends object>(fastRender: RenderFast<[NewCarryForward_15], NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>, NewCarryForward_16>): JayStackComponentDefinition<NewStaticViewState_5, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>>, ExtractRefs<Render>, [NewCarryForward_15], [Signals<NewCarryForward_16>, ...NewClientContexts_1], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>>>> & {
-                    withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>>, [Signals<NewCarryForward_16>, ...NewClientContexts_1], JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>>>>): JayStackComponentDefinition<NewStaticViewState_5, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>>, ExtractRefs<Render>, [NewCarryForward_15], [Signals<NewCarryForward_16>, ...NewClientContexts_1], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>>>>;
-                };
-                withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>, NewClientContexts_1, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>>>): JayStackComponentDefinition<NewStaticViewState_5, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>, ExtractRefs<Render>, [NewCarryForward_15], NewClientContexts_1, NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_5>>>;
-            };
-            withFastRender<NewCarryForward_17 extends object>(fastRender: RenderFast<[], NewPropsT, ExtractViewState<Render>, NewCarryForward_17>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, [], [Signals<NewCarryForward_17>, ...NewClientContexts_1], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>> & {
-                withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<ExtractViewState<Render>>, [Signals<NewCarryForward_17>, ...NewClientContexts_1], JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, [], [Signals<NewCarryForward_17>, ...NewClientContexts_1], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>>;
-            };
-            withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, ExtractViewState<Render>, NewClientContexts_1, JayComponentCore<NewPropsT, ExtractViewState<Render>>>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, [], NewClientContexts_1, NewPropsT, {}, JayComponentCore<NewPropsT, ExtractViewState<Render>>>;
-        };
-        withLoadParams<NewParams_3 extends UrlParams>(loadParams: LoadParams<[], NewParams_3>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, [], [], NewPropsT & NewParams_3, NewParams_3, JayComponentCore<NewPropsT, ExtractViewState<Render>>> & {
-            withSlowlyRender<NewStaticViewState_6 extends Partial<ExtractViewState<Render>>, NewCarryForward_18 extends object>(slowlyRender: RenderSlowly<[], NewPropsT & NewParams_3, NewStaticViewState_6, NewCarryForward_18>): JayStackComponentDefinition<NewStaticViewState_6, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>, ExtractRefs<Render>, [NewCarryForward_18], [], NewPropsT & NewParams_3, NewParams_3, JayComponentCore<NewPropsT & NewParams_3, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>>> & {
-                withFastRender<NewCarryForward_19 extends object>(fastRender: RenderFast<[NewCarryForward_18], NewPropsT & NewParams_3, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>, NewCarryForward_19>): JayStackComponentDefinition<NewStaticViewState_6, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>>, ExtractRefs<Render>, [NewCarryForward_18], [Signals<NewCarryForward_19>], NewPropsT & NewParams_3, NewParams_3, JayComponentCore<NewPropsT & NewParams_3, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>>>> & {
-                    withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_3, ExtractRefs<Render>, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>>, [Signals<NewCarryForward_19>], JayComponentCore<NewPropsT & NewParams_3, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>>>>): JayStackComponentDefinition<NewStaticViewState_6, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>>, ExtractRefs<Render>, [NewCarryForward_18], [Signals<NewCarryForward_19>], NewPropsT & NewParams_3, NewParams_3, JayComponentCore<NewPropsT & NewParams_3, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>>>>;
-                };
-                withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_3, ExtractRefs<Render>, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>, [], JayComponentCore<NewPropsT & NewParams_3, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>>>): JayStackComponentDefinition<NewStaticViewState_6, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>, ExtractRefs<Render>, [NewCarryForward_18], [], NewPropsT & NewParams_3, NewParams_3, JayComponentCore<NewPropsT & NewParams_3, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_6>>>;
-            };
-            withFastRender<NewCarryForward_20 extends object>(fastRender: RenderFast<[], NewPropsT & NewParams_3, ExtractViewState<Render>, NewCarryForward_20>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, [], [Signals<NewCarryForward_20>], NewPropsT & NewParams_3, NewParams_3, JayComponentCore<NewPropsT & NewParams_3, Partial<ExtractViewState<Render>>>> & {
-                withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_3, ExtractRefs<Render>, Partial<ExtractViewState<Render>>, [Signals<NewCarryForward_20>], JayComponentCore<NewPropsT & NewParams_3, Partial<ExtractViewState<Render>>>>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, [], [Signals<NewCarryForward_20>], NewPropsT & NewParams_3, NewParams_3, JayComponentCore<NewPropsT & NewParams_3, Partial<ExtractViewState<Render>>>>;
-            };
-            withInteractive(comp: ComponentConstructor<NewPropsT & NewParams_3, ExtractRefs<Render>, ExtractViewState<Render>, [], JayComponentCore<NewPropsT, ExtractViewState<Render>>>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, [], [], NewPropsT & NewParams_3, NewParams_3, JayComponentCore<NewPropsT, ExtractViewState<Render>>>;
-        };
-        withSlowlyRender<NewStaticViewState_7 extends Partial<ExtractViewState<Render>>, NewCarryForward_21 extends object>(slowlyRender: RenderSlowly<[], NewPropsT, NewStaticViewState_7, NewCarryForward_21>): JayStackComponentDefinition<NewStaticViewState_7, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>, ExtractRefs<Render>, [NewCarryForward_21], [], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>>> & {
-            withFastRender<NewCarryForward_22 extends object>(fastRender: RenderFast<[NewCarryForward_21], NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>, NewCarryForward_22>): JayStackComponentDefinition<NewStaticViewState_7, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>>, ExtractRefs<Render>, [NewCarryForward_21], [Signals<NewCarryForward_22>], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>>>> & {
-                withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>>, [Signals<NewCarryForward_22>], JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>>>>): JayStackComponentDefinition<NewStaticViewState_7, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>>, ExtractRefs<Render>, [NewCarryForward_21], [Signals<NewCarryForward_22>], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>>>>;
-            };
-            withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>, [], JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>>>): JayStackComponentDefinition<NewStaticViewState_7, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>, ExtractRefs<Render>, [NewCarryForward_21], [], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>> & Omit<ExtractViewState<Render>, keyof NewStaticViewState_7>>>;
-        };
-        withFastRender<NewCarryForward_23 extends object>(fastRender: RenderFast<[], NewPropsT, ExtractViewState<Render>, NewCarryForward_23>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, [], [Signals<NewCarryForward_23>], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>> & {
-            withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, Partial<ExtractViewState<Render>>, [Signals<NewCarryForward_23>], JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>>): JayStackComponentDefinition<object, Partial<ExtractViewState<Render>>, ExtractRefs<Render>, [], [Signals<NewCarryForward_23>], NewPropsT, {}, JayComponentCore<NewPropsT, Partial<ExtractViewState<Render>>>>;
-        };
-        withInteractive(comp: ComponentConstructor<NewPropsT, ExtractRefs<Render>, ExtractViewState<Render>, [], JayComponentCore<NewPropsT, ExtractViewState<Render>>>): JayStackComponentDefinition<object, ExtractViewState<Render>, ExtractRefs<Render>, [], [], NewPropsT, {}, JayComponentCore<NewPropsT, ExtractViewState<Render>>>;
-    };
-};
+        ...Contexts
+    ], PropsT, Params, JayComponentCore<PropsT, InteractiveVS>>;
+    withInteractive(comp: ComponentConstructor<PropsT, Refs, InteractiveVS, Contexts, CompCore>): Builder<'Done', Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore>;
+} : State extends 'InteractiveRender' ? JayStackComponentDefinition<Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore> & {
+    withInteractive(comp: ComponentConstructor<PropsT, Refs, InteractiveVS, Contexts, CompCore>): Builder<'Done', Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore>;
+} : JayStackComponentDefinition<Refs, SlowVS, FastVS, InteractiveVS, Services, Contexts, PropsT, Params, CompCore>;
+/**
+ * Create a Jay Stack component from a contract.
+ *
+ * For .jay-contract files with explicit phase annotations:
+ * - SlowViewState: Properties with phase: slow (or default)
+ * - FastViewState: Properties with phase: fast
+ * - InteractiveViewState: Properties with phase: fast+interactive
+ *
+ * For .jay-html files (backward compatible):
+ * - SlowViewState, FastViewState, InteractiveViewState default to `never`
+ *
+ * Note: Full type enforcement for phase-specific render functions requires
+ * extensive refactoring of the Builder type system. Currently, the phase types
+ * are extracted but not yet enforced. See design-log/50 for full implementation plan.
+ *
+ * TODO: Add type constraints to withSlowlyRender, withFastRender, withInteractive
+ * to enforce that returned/received ViewStates match the phase-specific types.
+ */
+declare function makeJayStackComponent<Render extends JayContract<any, any, any, any, any>>(): Builder<'Props', ExtractRefs<Render>, ExtractSlowViewState<Render>, ExtractFastViewState<Render>, ExtractInteractiveViewState<Render>, [
+], [
+], {}, {}, JayComponentCore<object, ExtractInteractiveViewState<Render>>>;
 
-export { type AnyFastRenderResult, type AnyJayStackComponentDefinition, type AnySlowlyRenderResult, type Builder, type ClientError4xx, type FastRenderResult, type JayStackComponentDefinition, type LoadParams, type PageProps, type PartialRender, type Redirect3xx, type RenderFast, type RenderSlowly, type ServerError5xx, type Signals, type SlowlyRenderResult, type UrlParams, clientError4xx, makeJayStackComponent, notFound, partialRender, redirect3xx, serverError5xx };
+export { type AnyFastRenderResult, type AnyJayStackComponentDefinition, type AnySlowlyRenderResult, type Builder, type ClientError4xx, type FastRenderResult, type JayStackComponentDefinition, type LoadParams, type PageProps, type PartialRender, type Redirect3xx, type RenderFast, type RenderSlowly, type ServerError5xx, type ServiceMarker, type ServiceMarkers, type Signals, type SlowlyRenderResult, type UrlParams, clientError4xx, createJayService, makeJayStackComponent, notFound, partialRender, redirect3xx, serverError5xx };

package/dist/index.js

@@ -29,10 +29,13 @@ function redirect3xx(status, location) {
 function partialRender(rendered, carryForward) {
   return { kind: "PartialRender", rendered, carryForward };
 }
+function createJayService(name) {
+  return Symbol(name);
+}
 class BuilderImplementation {
   constructor() {
-    __publicField(this, "serverContexts", []);
-    __publicField(this, "clientContexts", []);
+    __publicField(this, "services", []);
+    __publicField(this, "contexts", []);
     __publicField(this, "loadParams");
     __publicField(this, "slowlyRender");
     __publicField(this, "fastRender");
@@ -41,12 +44,12 @@ class BuilderImplementation {
   withProps() {
     return this;
   }
-  withServerContext(...contextMarkers) {
-    this.serverContexts = contextMarkers;
+  withServices(...serviceMarkers) {
+    this.services = serviceMarkers;
     return this;
   }
-  withClientContext(...contextMarkers) {
-    this.clientContexts = contextMarkers;
+  withContexts(...contextMarkers) {
+    this.contexts = contextMarkers;
     return this;
   }
   withLoadParams(loadParams) {
@@ -71,6 +74,7 @@ function makeJayStackComponent() {
 }
 export {
   clientError4xx,
+  createJayService,
   makeJayStackComponent,
   notFound,
   partialRender,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/fullstack-component",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "type": "module",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -26,12 +26,12 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@jay-framework/component": "^0.7.0",
-    "@jay-framework/runtime": "^0.7.0"
+    "@jay-framework/component": "^0.9.0",
+    "@jay-framework/runtime": "^0.9.0"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.7.0",
-    "@jay-framework/jay-cli": "^0.7.0",
+    "@jay-framework/dev-environment": "^0.9.0",
+    "@jay-framework/jay-cli": "^0.9.0",
     "@types/express": "^5.0.2",
     "@types/node": "^22.15.21",
     "nodemon": "^3.0.3",