@frontmcp/skills 1.1.2 → 1.2.1

package/catalog/frontmcp-setup/SKILL.md

@@ -126,6 +126,94 @@ Entry point for project setup and scaffolding. This skill helps you find the rig
 | Nx generator not found   | `@frontmcp/nx` not installed     | Run `npm install -D @frontmcp/nx`                                     |
 | Skills not loading       | Skills placed in wrong directory | Catalog skills go in top-level `skills/`, app skills in `src/skills/` |
 
+## Examples
+
+Each reference has matching examples under [`examples/<reference>/`](./examples/):
+
+### `frontmcp-skills-usage`
+
+| Example                                                                                        | Level        | Description                                                                                   |
+| ---------------------------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------- |
+| [`bundle-presets-scaffolding`](./examples/frontmcp-skills-usage/bundle-presets-scaffolding.md) | Intermediate | Use `--skills` flag during project creation to install a skill bundle preset.                 |
+| [`install-and-search-skills`](./examples/frontmcp-skills-usage/install-and-search-skills.md)   | Basic        | Install skills statically for Claude Code and use dynamic CLI search for on-demand discovery. |
+
+### `multi-app-composition`
+
+| Example                                                                                            | Level        | Description                                                                                     |
+| -------------------------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------- |
+| [`local-apps-with-shared-tools`](./examples/multi-app-composition/local-apps-with-shared-tools.md) | Basic        | Compose multiple local `@App` classes into a server with shared tools available to all apps.    |
+| [`per-app-auth-and-isolation`](./examples/multi-app-composition/per-app-auth-and-isolation.md)     | Advanced     | Configure mixed authentication modes and scope isolation for different apps in a single server. |
+| [`remote-and-esm-apps`](./examples/multi-app-composition/remote-and-esm-apps.md)                   | Intermediate | Compose local, ESM (npm package), and remote (external MCP server) apps into a single gateway.  |
+
+### `nx-workflow`
+
+| Example                                                                        | Level        | Description                                                                                                   |
+| ------------------------------------------------------------------------------ | ------------ | ------------------------------------------------------------------------------------------------------------- |
+| [`build-test-affected`](./examples/nx-workflow/build-test-affected.md)         | Intermediate | Use Nx commands for efficient building, testing, and CI with affected-only execution.                         |
+| [`multi-server-deployment`](./examples/nx-workflow/multi-server-deployment.md) | Advanced     | Generate multiple servers in an Nx workspace, each composing different apps for different deployment targets. |
+| [`scaffold-and-generate`](./examples/nx-workflow/scaffold-and-generate.md)     | Basic        | Initialize an Nx workspace and use generators to scaffold an app with tools, resources, and a server.         |
+
+### `project-structure-nx`
+
+| Example                                                                                   | Level        | Description                                                                                                                    |
+| ----------------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------ |
+| [`nx-generator-scaffolding`](./examples/project-structure-nx/nx-generator-scaffolding.md) | Basic        | Use `@frontmcp/nx` generators to scaffold tools, resources, and providers within an app, with automatic barrel export updates. |
+| [`nx-workspace-with-apps`](./examples/project-structure-nx/nx-workspace-with-apps.md)     | Basic        | Scaffold an Nx monorepo with two apps and a server that composes them into a single gateway.                                   |
+| [`shared-library-usage`](./examples/project-structure-nx/shared-library-usage.md)         | Intermediate | Create a shared library in an Nx monorepo and use it from multiple apps to avoid cross-app imports.                            |
+
+### `project-structure-standalone`
+
+| Example                                                                                                 | Level        | Description                                                                                                                 |
+| ------------------------------------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------- |
+| [`dev-workflow-commands`](./examples/project-structure-standalone/dev-workflow-commands.md)             | Basic        | Run the standard development workflow for a standalone FrontMCP project: dev server, build, and tests.                      |
+| [`feature-folder-organization`](./examples/project-structure-standalone/feature-folder-organization.md) | Intermediate | Organize a growing standalone project into domain-specific feature folders instead of flat type-based directories.          |
+| [`minimal-standalone-layout`](./examples/project-structure-standalone/minimal-standalone-layout.md)     | Basic        | Set up the canonical file structure for a standalone FrontMCP project with one app, one tool, and the required entry point. |
+
+### `readme-guide`
+
+| Example                                                                           | Level        | Description                                                                                            |
+| --------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------ |
+| [`node-server-readme`](./examples/readme-guide/node-server-readme.md)             | Basic        | Generate a README for a FrontMCP server deployed as a Docker/Node.js service with tools and resources. |
+| [`vercel-deployment-readme`](./examples/readme-guide/vercel-deployment-readme.md) | Intermediate | Generate a README for a FrontMCP server deployed to Vercel with Vercel KV storage.                     |
+
+### `setup-project`
+
+| Example                                                                            | Level        | Description                                                                                                                                           |
+| ---------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`basic-node-server`](./examples/setup-project/basic-node-server.md)               | Basic        | Scaffold a minimal FrontMCP server with one app and one tool, running on Node.js with HTTP transport.                                                 |
+| [`cli-scaffold-with-flags`](./examples/setup-project/cli-scaffold-with-flags.md)   | Basic        | Use the `frontmcp create` CLI to scaffold a complete project non-interactively with explicit flags for deployment target, Redis, and package manager. |
+| [`vercel-serverless-server`](./examples/setup-project/vercel-serverless-server.md) | Intermediate | Configure a FrontMCP server for Vercel deployment with Vercel KV storage and modern transport protocol.                                               |
+
+### `setup-redis`
+
+| Example                                                                                  | Level        | Description                                                                                                                                   |
+| ---------------------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`docker-redis-local-dev`](./examples/setup-redis/docker-redis-local-dev.md)             | Basic        | Provision Redis with Docker Compose and connect a FrontMCP server for local session storage.                                                  |
+| [`hybrid-vercel-kv-with-pubsub`](./examples/setup-redis/hybrid-vercel-kv-with-pubsub.md) | Advanced     | Use Vercel KV for session storage and a separate Redis instance for pub/sub resource subscriptions in distributed multi-instance deployments. |
+| [`vercel-kv-serverless`](./examples/setup-redis/vercel-kv-serverless.md)                 | Intermediate | Configure a FrontMCP server with Vercel KV as the session store for serverless deployment.                                                    |
+
+### `setup-sqlite`
+
+| Example                                                                           | Level        | Description                                                                                       |
+| --------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------- |
+| [`basic-sqlite-setup`](./examples/setup-sqlite/basic-sqlite-setup.md)             | Basic        | Configure a FrontMCP server with SQLite for local session storage with WAL mode enabled.          |
+| [`encrypted-sqlite-storage`](./examples/setup-sqlite/encrypted-sqlite-storage.md) | Intermediate | Enable AES-256-GCM at-rest encryption for sensitive session data stored in SQLite.                |
+| [`unix-socket-daemon`](./examples/setup-sqlite/unix-socket-daemon.md)             | Advanced     | Configure a FrontMCP daemon that listens on a unix socket and uses SQLite for persistent storage. |
+
+## Accessing This Skill
+
+Skills are distributed as plain SKILL.md files plus a sibling `references/`
+and `examples/` tree, so consumers can pick whichever access mode fits:
+
+| Mode               | How it works                                                                                                                                                                                                                                                                                                                                  |
+| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Filesystem**     | Read `libs/skills/catalog/frontmcp-setup/` directly from a clone of the catalog repo, or from a published `@frontmcp/skills` install. SKILL.md is the entry point.                                                                                                                                                                            |
+| **`frontmcp` CLI** | `frontmcp skills list`, `frontmcp skills read frontmcp-setup`, `frontmcp skills read frontmcp-setup:references/<file>.md`, `frontmcp skills install frontmcp-setup` — no server required.                                                                                                                                                     |
+| **MCP `skill://`** | When a developer mounts this skill into their own FrontMCP server (`@FrontMcp({ skills: [...] })`), the SDK exposes it via SEP-2640 resources: `skill://frontmcp-setup/SKILL.md`, `skill://frontmcp-setup/references/{file}.md`, etc. The server’s `skill://index.json` returns the SEP-2640 discovery document for everything mounted on it. |
+
+The catalog itself is **not** an MCP server. The `skill://` URIs only resolve
+when a server has been configured to host this skill.
+
 ## Reference
 
 - [Getting Started](https://docs.agentfront.dev/frontmcp/getting-started/quickstart)

package/catalog/frontmcp-setup/examples/project-structure-nx/nx-workspace-with-apps.md

@@ -19,23 +19,26 @@ Scaffold an Nx monorepo with two apps and a server that composes them into a sin
 
 ```bash
 # Scaffold the Nx workspace
+# (creates apps/.gitkeep, libs/.gitkeep, servers/.gitkeep, and a sample apps/demo app)
 npx frontmcp create my-workspace --nx
 
 cd my-workspace
 
-# Generate two apps
+# Generate two apps (billing and crm)
 nx g @frontmcp/nx:app billing
 nx g @frontmcp/nx:app crm
 
-# Generate a server composing both apps
+# Generate a server that composes both apps
+# Servers are NOT created by the workspace generator -- you must add them with this command
 nx g @frontmcp/nx:server gateway --apps=billing,crm
 ```
 
 ```typescript
 // apps/billing/src/billing.app.ts
 import { App } from '@frontmcp/sdk';
-import { CreateInvoiceTool } from './tools/create-invoice.tool';
+
 import { InvoiceResource } from './resources/invoice.resource';
+import { CreateInvoiceTool } from './tools/create-invoice.tool';
 
 @App({
   name: 'billing',
@@ -48,6 +51,7 @@ export class BillingApp {}
 ```typescript
 // apps/crm/src/crm.app.ts
 import { App } from '@frontmcp/sdk';
+
 import { LookupUserTool } from './tools/lookup-user.tool';
 
 @App({
@@ -60,10 +64,12 @@ export class CrmApp {}
 ```typescript
 // servers/gateway/src/main.ts
 import 'reflect-metadata';
-import { FrontMcp } from '@frontmcp/sdk';
+
 import { BillingApp } from '@my-workspace/billing';
 import { CrmApp } from '@my-workspace/crm';
 
+import { FrontMcp } from '@frontmcp/sdk';
+
 @FrontMcp({
   info: { name: 'gateway', version: '1.0.0' },
   apps: [BillingApp, CrmApp],

package/catalog/frontmcp-setup/examples/project-structure-standalone/dev-workflow-commands.md

@@ -31,22 +31,35 @@ frontmcp build --target cloudflare
 ```
 
 ```bash
-# Run unit tests (test files use .spec.ts extension)
-jest
+# Run unit and E2E tests (auto-discovers *.spec.ts and e2e/*.e2e.spec.ts)
+# Do NOT create a standalone jest.e2e.config.ts -- frontmcp test generates one automatically
+frontmcp test
 ```
 
-```bash
-# Run E2E tests from the e2e/ directory
-jest --config e2e/jest.config.ts
+```typescript
+// To run with HTTP transport, set http: { port } in the @FrontMcp metadata.
+// Setting PORT=3000 alone does NOT switch the server from stdio to HTTP.
+import 'reflect-metadata';
+
+import { FrontMcp } from '@frontmcp/sdk';
+
+import { CalcApp } from './calc.app';
+
+@FrontMcp({
+  info: { name: 'demo', version: '0.1.0' },
+  apps: [CalcApp],
+  http: { port: 3000 }, // <-- enables HTTP transport on port 3000
+})
+export default class Server {}
 ```
 
 ```bash
-# Start the dev server with HTTP transport on a specific port
-PORT=3000 frontmcp dev
+# With http: { port } configured in metadata, start the dev server
+frontmcp dev
 ```
 
 ```bash
-# Test the running server with an MCP initialize request
+# Test the running HTTP server with an MCP initialize request
 curl -X POST http://localhost:3000/mcp \
   -H "Content-Type: application/json" \
   -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"0.1.0"}}}'

package/catalog/frontmcp-setup/examples/readme-guide/node-server-readme.md

@@ -7,7 +7,7 @@ tags: [setup, docker, readme, node]
 features:
   - 'Standard README sections: Features, Quick Start, Tools table, Resources table, Environment Variables'
   - 'Docker-specific deployment section with build and run commands'
-  - 'Development commands using `frontmcp dev`, `frontmcp test`, `frontmcp inspect`'
+  - 'Development commands using `frontmcp dev`, `frontmcp test`, `frontmcp inspector`'
   - 'Tool and resource tables generated from source code decorators'
 ---
 
@@ -65,7 +65,7 @@ npm run dev
 
 frontmcp dev # Start dev server with hot reload
 frontmcp test # Run tests
-frontmcp inspect # Inspect MCP server capabilities
+frontmcp inspector # Inspect MCP server capabilities
 
 ## Docker Deployment
 
@@ -81,7 +81,7 @@ MIT
 
 - Standard README sections: Features, Quick Start, Tools table, Resources table, Environment Variables
 - Docker-specific deployment section with build and run commands
-- Development commands using `frontmcp dev`, `frontmcp test`, `frontmcp inspect`
+- Development commands using `frontmcp dev`, `frontmcp test`, `frontmcp inspector`
 - Tool and resource tables generated from source code decorators
 
 ## Related

package/catalog/frontmcp-setup/references/multi-app-composition.md

@@ -72,7 +72,7 @@ export default class Server {}
 Load an `@App`-decorated class from an npm package at runtime using `app.esm()`. The package is fetched, cached, and its default export is treated as a local app.
 
 ```typescript
-import { FrontMcp, app } from '@frontmcp/sdk';
+import { app, FrontMcp } from '@frontmcp/sdk';
 
 @FrontMcp({
   info: { name: 'gateway', version: '1.0.0' },
@@ -112,7 +112,7 @@ app.esm('@internal/tools@^2.0.0', {
 Proxy tools, resources, and prompts from an external MCP server using `app.remote()`. The gateway connects via Streamable HTTP (with SSE fallback) and exposes the remote primitives as if they were local.
 
 ```typescript
-import { FrontMcp, app } from '@frontmcp/sdk';
+import { app, FrontMcp } from '@frontmcp/sdk';
 
 @FrontMcp({
   info: { name: 'gateway', version: '1.0.0' },
@@ -313,7 +313,8 @@ Combining all patterns into a single server:
 
 ```typescript
 import 'reflect-metadata';
-import { FrontMcp, App, app } from '@frontmcp/sdk';
+
+import { App, app, FrontMcp } from '@frontmcp/sdk';
 
 // Local app with per-app auth and plugins
 @App({

package/catalog/frontmcp-setup/references/project-structure-nx.md

@@ -27,12 +27,17 @@ description: Canonical directory layout, generators, and dependency rules for Fr
 
 > **Decision:** Use this skill when setting up or organizing a FrontMCP Nx monorepo and you need the canonical directory layout, generator commands, and dependency rules.
 
-When you scaffold with `frontmcp create --nx` or add FrontMCP to an existing Nx workspace, the recommended layout separates apps, shared libraries, and server entry points:
+When you scaffold with `frontmcp create --nx` (or run `nx g @frontmcp/nx:workspace` standalone), the generator produces an empty `apps/`, `libs/`, and `servers/` skeleton plus a sample `apps/demo` app. Servers are NOT created automatically -- you must run `nx g @frontmcp/nx:server <name> --apps=<app-list>` separately. Once you add apps, libs, and a server, the recommended layout looks like this:
 
 ```text
 my-workspace/
 ├── apps/                     # @App classes (one app per directory)
-│   ├── billing/
+│   ├── demo/                 # sample app generated by the workspace generator
+│   │   ├── src/
+│   │   │   └── demo.app.ts
+│   │   ├── project.json
+│   │   └── tsconfig.json
+│   ├── billing/              # added by `nx g @frontmcp/nx:app billing`
 │   │   ├── src/
 │   │   │   ├── billing.app.ts
 │   │   │   ├── tools/
@@ -54,7 +59,7 @@ my-workspace/
 │       ├── project.json
 │       └── tsconfig.json
 ├── servers/                  # @FrontMcp servers composing apps
-│   └── gateway/
+│   └── gateway/              # generated by `nx g @frontmcp/nx:server gateway --apps=billing,crm`
 │       ├── src/
 │       │   └── main.ts       # @FrontMcp default export
 │       ├── project.json
@@ -67,6 +72,8 @@ my-workspace/
 └── .cursorrules
 ```
 
+> **Out of the box:** The workspace generator only creates `apps/.gitkeep`, `libs/.gitkeep`, `servers/.gitkeep`, the workspace files (`nx.json`, `tsconfig.base.json`, `package.json`, etc.), and a sample `apps/demo` app. Add apps, libs, and servers explicitly with the corresponding generators below.
+
 ## Directory Roles
 
 ### apps/ -- Application Modules
@@ -76,9 +83,10 @@ Each directory under `apps/` contains a single `@App` class with its tools, reso
 ```typescript
 // apps/billing/src/billing.app.ts
 import { App } from '@frontmcp/sdk';
-import { CreateInvoiceTool } from './tools/create-invoice.tool';
-import { InvoiceResource } from './resources/invoice.resource';
+
 import { StripeProvider } from './providers/stripe.provider';
+import { InvoiceResource } from './resources/invoice.resource';
+import { CreateInvoiceTool } from './tools/create-invoice.tool';
 
 @App({
   name: 'billing',
@@ -114,10 +122,11 @@ A server composes multiple apps into a single `@FrontMcp` entry point:
 
 ```typescript
 // servers/gateway/src/main.ts
-import { FrontMcp } from '@frontmcp/sdk';
 import { BillingApp } from '@my-workspace/billing';
 import { CrmApp } from '@my-workspace/crm';
 
+import { FrontMcp } from '@frontmcp/sdk';
+
 @FrontMcp({
   info: { name: 'gateway', version: '1.0.0' },
   apps: [BillingApp, CrmApp],

package/catalog/frontmcp-setup/references/project-structure-standalone.md

@@ -74,6 +74,7 @@ Every entity type uses a consistent `<name>.<type>.ts` pattern:
 
 ```typescript
 import { FrontMcp } from '@frontmcp/sdk';
+
 import { MyApp } from './my-app.app';
 
 @FrontMcp({
@@ -91,8 +92,9 @@ The `@App` class groups tools, resources, prompts, plugins, and providers togeth
 
 ```typescript
 import { App } from '@frontmcp/sdk';
-import { FetchWeatherTool } from './tools/fetch-weather.tool';
+
 import { DatabaseProvider } from './providers/database.provider';
+import { FetchWeatherTool } from './tools/fetch-weather.tool';
 
 @App({
   name: 'my-app',
@@ -121,18 +123,17 @@ frontmcp build --target vercel
 frontmcp build --target lambda
 ```
 
-Valid targets: `cli`, `node`, `sdk`, `browser`, `cloudflare`, `vercel`, `lambda`. The `--target` flag determines the output format and runtime optimizations.
+Valid targets: `cli`, `node`, `sdk`, `browser`, `cloudflare`, `vercel`, `lambda`, `distributed`, `mcpb`. The `--target` flag determines the output format and runtime optimizations.
 
 ### Run tests
 
 ```bash
-# Unit tests
-jest
-
-# E2E tests
-jest --config e2e/jest.config.ts
+# Unit and E2E tests (auto-discovers *.spec.ts and e2e/*.e2e.spec.ts)
+frontmcp test
 ```
 
+> **Do not** create a standalone `jest.e2e.config.ts` -- `frontmcp test` auto-generates the correct Jest/SWC configuration for both unit and E2E tests. The CLI scaffolder explicitly removes `jest.e2e.config.ts` and `tsconfig.e2e.json` for the same reason.
+
 ## Organizing by Feature
 
 For larger standalone projects, group related entities into feature folders:
@@ -192,8 +193,9 @@ Skills inside `src/skills/` are `@Skill` classes that are part of your applicati
 
 - [ ] `frontmcp dev` starts the development server with file watching
 - [ ] `frontmcp build --target node` produces a valid production build
-- [ ] Unit tests pass with `jest`
+- [ ] Unit and E2E tests pass with `frontmcp test`
 - [ ] E2E tests (if any) are in the `e2e/` directory with `*.e2e.spec.ts` naming
+- [ ] No standalone `jest.e2e.config.ts` exists -- the CLI auto-generates the test config
 
 ### Organization
 
@@ -203,13 +205,14 @@ Skills inside `src/skills/` are `@Skill` classes that are part of your applicati
 
 ## Troubleshooting
 
-| Problem                        | Cause                                                         | Solution                                                                 |
-| ------------------------------ | ------------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `frontmcp dev` fails to start  | `main.ts` does not default-export the `@FrontMcp` class       | Add `export default MyServer` to `main.ts`                               |
-| Tool not discovered at runtime | Tool class not added to the `tools` array in `@App`           | Register the tool in the `@App` decorator's `tools` array                |
-| Tests not found by Jest        | Test file uses `.test.ts` instead of `.spec.ts`               | Rename to `.spec.ts` to match the FrontMCP test file convention          |
-| Build target error             | Invalid `--target` flag value                                 | Use `node`, `vercel`, `lambda`, or `cloudflare` as the target value      |
-| Catalog skills not loaded      | Skills placed in `src/skills/` instead of top-level `skills/` | Move catalog `SKILL.md` directories to the top-level `skills/` directory |
+| Problem                                  | Cause                                                           | Solution                                                                                               |
+| ---------------------------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `frontmcp dev` fails to start            | `main.ts` does not default-export the `@FrontMcp` class         | Add `export default MyServer` to `main.ts`                                                             |
+| Tool not discovered at runtime           | Tool class not added to the `tools` array in `@App`             | Register the tool in the `@App` decorator's `tools` array                                              |
+| Tests not found by Jest                  | Test file uses `.test.ts` instead of `.spec.ts`                 | Rename to `.spec.ts` to match the FrontMCP test file convention                                        |
+| `frontmcp test` fails to find E2E config | Custom `jest.e2e.config.ts` overrides the auto-generated config | Delete the standalone `jest.e2e.config.ts`; `frontmcp test` generates the correct config automatically |
+| Build target error                       | Invalid `--target` flag value                                   | Use one of `cli`, `node`, `sdk`, `browser`, `cloudflare`, `vercel`, `lambda`, `distributed`, `mcpb`    |
+| Catalog skills not loaded                | Skills placed in `src/skills/` instead of top-level `skills/`   | Move catalog `SKILL.md` directories to the top-level `skills/` directory                               |
 
 ## Examples
 

package/catalog/frontmcp-setup/references/readme-guide.md

@@ -217,7 +217,7 @@ Only update:
 - [ ] README includes all resources and their URIs
 - [ ] Installation instructions match the deployment target
 - [ ] Environment variables match `.env.example`
-- [ ] Development section includes `frontmcp dev`, `frontmcp test`, `frontmcp inspect`
+- [ ] Development section includes `frontmcp dev`, `frontmcp test`, `frontmcp inspector`
 - [ ] License matches `package.json`
 
 ## Examples

package/catalog/frontmcp-setup/references/setup-project.md

@@ -35,7 +35,7 @@ The `frontmcp` CLI generates a complete project structure. Run it with `npx`:
 npx frontmcp create <projectName>
 ```
 
-The CLI will interactively prompt for deployment target, Redis setup, package manager, CI/CD, and skills bundle. To skip prompts, pass flags directly:
+The CLI interactively prompts for project type (standalone vs Nx), deployment target, Redis setup, package manager, and CI/CD. The skills bundle is **not** prompted -- it defaults to `recommended` unless you pass the `--skills` flag explicitly. To skip the prompts entirely, pass flags directly:
 
 ```bash
 npx frontmcp create <projectName> \
@@ -93,10 +93,10 @@ Create `package.json`:
     "frontmcp": "latest",
     "@frontmcp/sdk": "latest",
     "reflect-metadata": "^0.2.0",
-    "zod": "^3.23.0"
+    "zod": "^4.0.0"
   },
   "devDependencies": {
-    "typescript": "^5.4.0",
+    "typescript": "^5.5.3",
     "@types/node": "^22.0.0"
   }
 }
@@ -358,10 +358,21 @@ Or if using package.json scripts:
 yarn dev
 ```
 
-The server starts in stdio mode by default. To test with HTTP transport, set the PORT:
+The server starts in stdio mode by default. To enable HTTP transport, add an `http: { port }` block to the `@FrontMcp` metadata (setting the `PORT` environment variable alone does **not** switch from stdio to HTTP):
+
+```typescript
+@FrontMcp({
+  info: { name: '<projectName>', version: '0.1.0' },
+  apps: [CalcApp],
+  http: { port: 3000 },
+})
+export default class Server {}
+```
+
+Then start the server normally:
 
 ```bash
-PORT=3000 frontmcp dev
+frontmcp dev
 ```
 
 Test with curl:
@@ -382,6 +393,9 @@ frontmcp build --target cloudflare    # Cloudflare Workers
 frontmcp build --target cli           # CLI with SEA binary
 frontmcp build --target cli --js      # CLI without SEA
 frontmcp build --target sdk           # Library (CJS+ESM+types)
+frontmcp build --target browser       # Browser bundle
+frontmcp build --target distributed   # Distributed runtime bundle
+frontmcp build --target mcpb          # MCPB archive (use --sea for SEA binary)
 ```
 
 ## Step 7 -- Nx Workspace Setup (optional)

package/catalog/frontmcp-setup/references/setup-redis.md

@@ -94,6 +94,7 @@ Update the `@FrontMcp` decorator in `src/main.ts`:
 
 ```typescript
 import 'reflect-metadata';
+
 import { FrontMcp } from '@frontmcp/sdk';
 
 @FrontMcp({
@@ -141,6 +142,7 @@ redis: {
 
 ```typescript
 import 'reflect-metadata';
+
 import { FrontMcp } from '@frontmcp/sdk';
 
 @FrontMcp({
@@ -169,53 +171,39 @@ redis: {
 },
 ```
 
-## Step 3 -- Session Store Factory (Advanced)
+## Step 3 -- How the SDK Builds the Session Store
 
-The SDK creates the session store automatically from the `redis` config. For advanced scenarios where you need direct access to the session store factory:
-
-```typescript
-import { createSessionStore } from '@frontmcp/sdk';
+You do not call any factory yourself. The SDK constructs the session store internally from the `redis` field on the `@FrontMcp` decorator. The framework handles:
 
-// Redis provider
-const sessionStore = await createSessionStore({
-  provider: 'redis',
-  host: 'localhost',
-  port: 6379,
-  keyPrefix: 'mcp:',
-});
+- Lazy-loading `ioredis` or `@vercel/kv` to avoid bundling unused dependencies
+- Automatic key prefix namespacing (appends `session:` to the base prefix you supply)
+- Pre-connection for Vercel KV
+- Falling back to an in-memory store when no `redis` (or `sqlite`) config is provided (single-instance dev only)
 
-// Vercel KV provider (requires await for pre-connection)
-const sessionStore = await createSessionStore({
-  provider: 'vercel-kv',
-  keyPrefix: 'mcp:',
-});
-```
+In other words, the only public API you interact with is the `redis: { ... }` block in the decorator config from Step 2. There is no `createSessionStore` helper exported from `@frontmcp/sdk` -- session store wiring is an internal concern of the framework.
 
-The `createSessionStore()` function signature:
+If you need to share the same Redis config in another part of your code, declare it once and reuse it:
 
 ```typescript
-async function createSessionStore(
-  options: RedisOptions, // RedisProviderOptions | VercelKvProviderOptions | legacy format
-  logger?: FrontMcpLogger,
-): Promise<SessionStore>;
-```
-
-The factory function handles:
-
-- Lazy-loading `ioredis` or `@vercel/kv` to avoid bundling unused dependencies
-- Automatic key prefix namespacing (appends `session:` to the base prefix)
-- Pre-connection for Vercel KV (the `await` is required)
-
-There is also a synchronous variant for Redis-only (does not support Vercel KV):
+import 'reflect-metadata';
 
-```typescript
-import { createSessionStoreSync } from '@frontmcp/sdk';
+import { FrontMcp, type RedisOptionsInput } from '@frontmcp/sdk';
 
-const sessionStore = createSessionStoreSync({
+const redis: RedisOptionsInput = {
   provider: 'redis',
-  host: 'localhost',
-  port: 6379,
-});
+  host: process.env['REDIS_HOST'] ?? 'localhost',
+  port: parseInt(process.env['REDIS_PORT'] ?? '6379', 10),
+  keyPrefix: 'mcp:',
+};
+
+@FrontMcp({
+  info: { name: 'my-server', version: '0.1.0' },
+  apps: [
+    /* ... */
+  ],
+  redis,
+})
+export default class Server {}
 ```
 
 ## Step 4 -- Pub/Sub for Resource Subscriptions (Multi-Instance Only)
@@ -321,7 +309,7 @@ You should see session keys like `mcp:session:<session-id>`.
 
 ## Common Patterns
 
-| Pattern                | Correct                                                                                    | Incorrect                                               | Why                                                                                                                                                                                        |
+| Pattern                | Recommended                                                                                | Less explicit                                           | Why                                                                                                                                                                                        |
 | ---------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | Redis provider field   | `redis: { provider: 'redis', host: '...', port: 6379 }`                                    | `redis: { host: '...', port: 6379 }` without `provider` | Both forms are type-safe (the SDK's `RedisOptions` union accepts both shapes), but explicit `provider: 'redis'` improves clarity and intent                                                |
 | Environment variables  | `host: process.env['REDIS_HOST'] ?? 'localhost'`                                           | Hardcoding `host: 'redis.internal'` in source           | Hardcoded values break across environments (dev, staging, prod); always read from env with a sensible fallback                                                                             |

package/catalog/frontmcp-setup/references/setup-sqlite.md

@@ -80,6 +80,7 @@ Update the `@FrontMcp` decorator in `src/main.ts`:
 
 ```typescript
 import 'reflect-metadata';
+
 import { FrontMcp } from '@frontmcp/sdk';
 
 @FrontMcp({
@@ -188,34 +189,40 @@ sqlite: {
 },
 ```
 
-## Step 4 -- Session Store Factory (Advanced)
+## Step 4 -- How the SDK Builds the SQLite Session Store
+
+You do not call any factory yourself. The SDK constructs the SQLite session store internally from the `sqlite` field on the `@FrontMcp` decorator. The framework handles:
+
+- Lazy-loading `@frontmcp/storage-sqlite` to avoid bundling native modules when not used
+- WAL mode pragma configuration
+- TTL cleanup interval setup for automatic key expiration
+- Creating the database file and parent directories if they do not exist
 
-The SDK creates the SQLite session store automatically from the `sqlite` config in the `@FrontMcp` decorator. For advanced scenarios where you need direct access to the factory function:
+In other words, the only public API you interact with is the `sqlite: { ... }` block in the decorator config from Step 2. There is no `createSqliteSessionStore` helper exported from `@frontmcp/sdk` -- session store wiring is an internal concern of the framework.
+
+If you need to share the same SQLite config in another part of your code, declare it once and reuse it:
 
 ```typescript
-import { createSqliteSessionStore } from '@frontmcp/sdk';
+import 'reflect-metadata';
 
-const sessionStore = createSqliteSessionStore({
+import { FrontMcp, type SqliteOptionsInput } from '@frontmcp/sdk';
+
+const sqlite: SqliteOptionsInput = {
   path: '~/.frontmcp/data/sessions.sqlite',
   walMode: true,
   encryption: { secret: process.env['SQLITE_ENCRYPTION_SECRET']! },
-});
-```
+};
 
-The `createSqliteSessionStore()` function signature:
-
-```typescript
-function createSqliteSessionStore(options: SqliteOptionsInput, logger?: FrontMcpLogger): SessionStore;
+@FrontMcp({
+  info: { name: 'my-server', version: '0.1.0' },
+  apps: [
+    /* ... */
+  ],
+  sqlite,
+})
+export default class Server {}
 ```
 
-The factory function:
-
-- Lazy-loads `@frontmcp/storage-sqlite` to avoid bundling native modules when not used
-- Handles WAL mode pragma configuration internally
-- Sets up the TTL cleanup interval for automatic key expiration
-- Creates the database file and parent directories if they do not exist
-- Returns synchronously (unlike the Redis `createSessionStore` which is async)
-
 ## Step 5 -- Environment Variables
 
 Add to your `.env` file: