devstack 0.1.0

package/vendor/skills/skills/rivetkit/reference/self-hosting/railway.md

@@ -0,0 +1,71 @@
+# Railway Deployment
+
+> Source: `src/content/docs/self-hosting/railway.mdx`
+> Canonical URL: https://rivet.dev/docs/self-hosting/railway
+> Description: Railway provides a simple platform for deploying Rivet Engine with automatic scaling and managed infrastructure.
+
+---
+
+## Video Tutorial
+
+## Quick Deploy
+
+Choose the template that best fits your needs:
+
+| **Rivet Template**                                                                                                                                                           | **Rivet Starter**                                                                                   |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| [![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/rivet?referralCode=RC7bza&utm_medium=integration&utm_source=template&utm_campaign=generic) | [![Deploy Rivet Starter](https://railway.com/button.svg)](https://railway.com/deploy/rivet-starter) |
+| **Blank template** to start fresh                                                                                                                                            | **Complete example** with chat app                                                                  |
+| - Rivet Engine                                                                                                                                                               | - Pre-configured Rivet Engine                                                                       |
+| - PostgreSQL database                                                                                                                                                        | - Example chat application with Actors                                                              |
+| - Basic configuration                                                                                                                                                        | - PostgreSQL database                                                                               |
+| - Manual setup required                                                                                                                                                      | - Rivet Inspector for debugging                                                                     |
+|                                                                                                                                                                              | - Ready to run immediately                                                                          |
+
+You can also use the [Rivet Railway template](https://github.com/rivet-dev/template-railway) as a starting point for your application.
+
+After deploying either template, you can find the `RIVET__AUTH__ADMIN_TOKEN` under the **Variables** tab in the Railway dashboard. This token is required to access the Rivet Inspector.
+
+## Manual Deployment
+
+### Prerequisites
+
+1. [Railway account](https://railway.app)
+2. [Railway CLI](https://docs.railway.app/develop/cli) (optional)
+
+### Step 1: Create New Project
+
+```bash
+# Using Railway CLI
+railway init
+
+# Or create via dashboard
+# https://railway.app/new
+```
+
+### Step 2: Add Services
+
+#### Deploy PostgreSQL Database
+
+1. Click "New Service" → "Database" → "PostgreSQL"
+2. Railway automatically provisions and configures PostgreSQL
+3. Note the connection string from the service variables
+
+#### Deploy Rivet Engine
+
+1. Click "New Service" → "Docker Image"
+2. Set image: `rivetdev/engine:latest`
+3. Configure environment variables:
+   - `RIVET__POSTGRES__URL=${{Postgres.DATABASE_URL}}`
+
+### Step 3: Deploy Your Application
+
+Follow the [Railway Quick Start guide](https://docs.railway.com/quick-start) to deploy your repository:
+
+1. Connect your GitHub account to Railway
+2. Select your repository containing your Rivet application
+3. Railway will automatically detect and deploy your application
+4. Configure environment variables for your application:
+   - `RIVET_ENDPOINT=${{Rivet.RAILWAY_PRIVATE_DOMAIN}}` - Points to the Rivet Engine service's private domain
+
+_Source doc path: /docs/self-hosting/railway_

package/vendor/skills/skills/rivetkit-client-javascript/SKILL.md

@@ -0,0 +1,259 @@
+---
+name: "rivetkit-client-javascript"
+description: "RivetKit JavaScript client guidance. Use for browser, Node.js, or Bun clients that connect to Rivet Actors with rivetkit/client, create clients, call actions, or manage connections."
+---
+
+# RivetKit JavaScript Client
+
+Use this skill when building JavaScript clients (browser, Node.js, or Bun) that connect to Rivet Actors with `rivetkit/client`.
+
+## First Steps
+
+1. Install the client (latest: 2.1.0-rc.2)
+   ```bash
+   npm install rivetkit@2.1.0-rc.2
+   ```
+2. Create a client with `createClient()` and call actor actions.
+
+## Error Handling Policy
+
+- Prefer fail-fast behavior by default.
+- Avoid `try/catch` unless absolutely needed.
+- If a `catch` is used, handle the error explicitly, at minimum by logging it.
+
+## Getting Started
+
+See the [backend quickstart guide](/docs/actors/quickstart/backend) for getting started.
+
+## Minimal Client
+
+```ts client.ts
+import { createClient } from "rivetkit/client";
+import type { registry } from "./actors";
+
+const client = createClient<typeof registry>({
+  endpoint: "https://my-namespace:pk_...@api.rivet.dev",
+});
+const counter = client.counter.getOrCreate(["my-counter"]);
+const count = await counter.increment(1);
+```
+
+```ts actors.ts @hide
+import { actor, setup } from "rivetkit";
+
+export const counter = actor({
+  state: { count: 0 },
+  actions: {
+    increment: (c, x: number) => {
+      c.state.count += x;
+      return c.state.count;
+    },
+  },
+});
+
+export const registry = setup({
+  use: { counter },
+});
+```
+
+## Stateless vs Stateful
+
+```typescript
+import { createClient } from "rivetkit/client";
+
+const client = createClient();
+const handle = client.counter.getOrCreate(["my-counter"]);
+
+// Stateless: each call is independent
+await handle.increment(1);
+
+// Stateful: keep a connection open for realtime events
+const conn = handle.connect();
+conn.on("count", (value: number) => console.log(value));
+await conn.increment(1);
+```
+
+## Getting Actors
+
+```typescript
+import { createClient } from "rivetkit/client";
+
+const client = createClient();
+const room = client.chatRoom.getOrCreate(["room-42"]);
+const existing = client.chatRoom.get(["room-42"]);
+
+const created = await client.game.create(["game-1"], {
+  input: { mode: "ranked" },
+});
+
+const byId = client.chatRoom.getForId("actor-id");
+const resolvedId = await room.resolve();
+```
+
+## Connection Parameters
+
+```typescript
+import { createClient } from "rivetkit/client";
+
+const client = createClient();
+const chat = client.chatRoom.getOrCreate(["general"], {
+  params: { authToken: "jwt-token-here" },
+});
+
+const conn = chat.connect();
+```
+
+## Subscribing to Events
+
+```typescript
+import { createClient } from "rivetkit/client";
+
+const client = createClient();
+const conn = client.chatRoom.getOrCreate(["general"]).connect();
+conn.on("message", (msg: string) => console.log(msg));
+conn.once("gameOver", () => console.log("done"));
+```
+
+## Connection Lifecycle
+
+```typescript
+import { createClient } from "rivetkit/client";
+
+const client = createClient();
+const conn = client.chatRoom.getOrCreate(["general"]).connect();
+
+conn.onOpen(() => console.log("connected"));
+conn.onClose(() => console.log("disconnected"));
+conn.onError(err => console.error("error:", err));
+conn.onStatusChange(status => console.log("status:", status));
+
+await conn.dispose();
+```
+
+## Low-Level HTTP & WebSocket
+
+For actors that implement `onRequest` or `onWebSocket`, call them directly:
+
+```ts @nocheck
+import { createClient } from "rivetkit/client";
+
+const client = createClient();
+const handle = client.chatRoom.getOrCreate(["general"]);
+
+const response = await handle.fetch("history");
+const history = await response.json();
+
+const ws = await handle.webSocket("stream");
+ws.addEventListener("message", event => {
+  console.log("message:", event.data);
+});
+ws.send("hello");
+```
+
+## Calling from Backend
+
+```typescript
+import { Hono } from "hono";
+import { createClient } from "rivetkit/client";
+
+const app = new Hono();
+const client = createClient();
+
+app.post("/increment/:name", async c => {
+  const counterHandle = client.counter.getOrCreate([c.req.param("name")]);
+  const newCount = await counterHandle.increment(1);
+  return c.json({ count: newCount });
+});
+```
+
+## Error Handling
+
+```typescript
+import { ActorError } from "rivetkit/client";
+import { createClient } from "rivetkit/client";
+
+const client = createClient();
+
+try {
+  await client.user.getOrCreate(["user-123"]).updateUsername("ab");
+} catch (error) {
+  if (error instanceof ActorError) {
+    console.log(error.code, error.metadata);
+  }
+}
+```
+
+## Concepts
+
+### Keys
+
+Keys uniquely identify actor instances. Use compound keys (arrays) for hierarchical addressing:
+
+```ts client.ts
+import { createClient } from "rivetkit/client";
+import type { registry } from "./actors";
+
+const client = createClient<typeof registry>();
+
+// Compound key: [org, room]
+client.chatRoom.getOrCreate(["org-acme", "general"]);
+```
+
+```ts actors.ts @hide
+import { actor, setup } from "rivetkit";
+
+export const chatRoom = actor({
+  state: { messages: [] as string[] },
+  actions: {
+    getRoomInfo: c => ({ org: c.key[0], room: c.key[1] }),
+  },
+});
+
+export const registry = setup({
+  use: { chatRoom },
+});
+```
+
+Don't build keys with string interpolation like `"org:${userId}"` when `userId` contains user data. Use arrays instead to prevent key injection attacks.
+
+### Environment Variables
+
+`createClient()` automatically reads:
+
+- `RIVET_ENDPOINT` (endpoint)
+- `RIVET_NAMESPACE`
+- `RIVET_TOKEN`
+- `RIVET_RUNNER`
+
+Defaults to `window.location.origin + "/api/rivet"` in the browser or `http://127.0.0.1:6420` on the server when unset.
+
+### Endpoint Format
+
+Endpoints support URL auth syntax:
+
+```
+https://namespace:token@api.rivet.dev
+```
+
+You can also pass the endpoint without auth and provide `RIVET_NAMESPACE` and `RIVET_TOKEN` separately. For serverless deployments, use your app's `/api/rivet` URL. See [Endpoints](/docs/general/endpoints#url-auth-syntax) for details.
+
+## API Reference
+
+**Package:** [rivetkit](https://www.npmjs.com/package/rivetkit)
+
+See the [RivetKit client overview](/docs/clients).
+
+- [`createClient`](/typedoc/functions/rivetkit.client_mod.createClient.html) - Create a client
+- [`createEngineDriver`](/typedoc/functions/rivetkit.mod.createEngineDriver.html) - Engine driver
+- [`DriverConfig`](/typedoc/types/rivetkit.mod.DriverConfig.html) - Driver configuration
+- [`Client`](/typedoc/types/rivetkit.mod.Client.html) - Client type
+
+## Need More Than the Client?
+
+If you need more about Rivet Actors, registries, or server-side RivetKit, add the main skill:
+
+```bash
+npx skills add rivet-dev/skills
+```
+
+Then use the `rivetkit` skill for backend guidance.

package/vendor/skills/skills/rivetkit-client-javascript/index.json

@@ -0,0 +1,7 @@
+{
+    "name": "rivetkit-client-javascript",
+    "description": "RivetKit JavaScript client guidance. Use for browser, Node.js, or Bun clients that connect to Rivet Actors with rivetkit/client, create clients, call actions, or manage connections.",
+    "skill_url": "/metadata/skills/rivetkit-client-javascript/SKILL.md",
+    "generated_at": "2026-02-24T11:03:05.833Z",
+    "references": []
+}

package/vendor/skills/skills/rivetkit-client-react/SKILL.md

@@ -0,0 +1,293 @@
+---
+name: "rivetkit-client-react"
+description: "RivetKit React client guidance. Use for React apps that connect to Rivet Actors with @rivetkit/react, create hooks with createRivetKit, or manage realtime state with useActor."
+---
+
+# RivetKit React Client
+
+Use this skill when building React apps that connect to Rivet Actors with `@rivetkit/react`.
+
+## First Steps
+
+1. Install the React client (latest: 2.1.0-rc.2)
+   ```bash
+   npm install @rivetkit/react@2.1.0-rc.2
+   ```
+2. Create hooks with `createRivetKit()` and connect with `useActor()`.
+
+## Error Handling Policy
+
+- Prefer fail-fast behavior by default.
+- Avoid `try/catch` unless absolutely needed.
+- If a `catch` is used, handle the error explicitly, at minimum by logging it.
+
+## Getting Started
+
+See the [React quickstart guide](/docs/actors/quickstart/react) for getting started.
+
+## Install
+
+## Minimal Client
+
+```tsx Counter.tsx
+import { createRivetKit } from "@rivetkit/react";
+import type { registry } from "./actors";
+
+const { useActor } = createRivetKit<typeof registry>({
+  endpoint: "https://my-namespace:pk_...@api.rivet.dev",
+});
+
+function Counter() {
+  const { connection, connStatus } = useActor({ name: "counter", key: ["my-counter"] });
+
+  if (connStatus !== "connected" || !connection) return <div>Connecting...</div>;
+  return <button onClick={() => connection.increment(1)}>+</button>;
+}
+```
+
+```ts actors.ts @hide
+import { actor, setup } from "rivetkit";
+
+export const counter = actor({
+  state: { count: 0 },
+  actions: {
+    increment: (c, x: number) => {
+      c.state.count += x;
+      c.broadcast("newCount", c.state.count);
+      return c.state.count;
+    },
+  },
+});
+
+export const registry = setup({
+  use: { counter },
+});
+```
+
+## Stateless vs Stateful
+
+```tsx
+import { createRivetKit } from "@rivetkit/react";
+
+const { useActor } = createRivetKit();
+
+function Counter() {
+  const counter = useActor({ name: "counter", key: ["my-counter"] });
+
+  const increment = async () => {
+    await counter.connection?.increment(1);
+  };
+
+  return <button onClick={increment}>+</button>;
+}
+```
+
+```tsx
+// Stateless: use createClient for one-off calls (SSR or utilities)
+import { createClient } from "rivetkit/client";
+
+const client = createClient();
+await client.counter.getOrCreate(["my-counter"]).increment(1);
+```
+
+## Getting Actors
+
+```tsx
+import { createRivetKit } from "@rivetkit/react";
+import { createClient } from "rivetkit/client";
+
+const { useActor } = createRivetKit();
+
+function ChatRoom() {
+  const room = useActor({ name: "chatRoom", key: ["room-42"] });
+  return <div>{room.connStatus}</div>;
+}
+
+// For get/getOrCreate/create/getForId, use createClient
+const client = createClient();
+const handle = client.chatRoom.getOrCreate(["room-42"]);
+const existing = client.chatRoom.get(["room-42"]);
+const created = await client.game.create(["game-1"], { input: { mode: "ranked" } });
+const byId = client.chatRoom.getForId("actor-id");
+const resolvedId = await handle.resolve();
+```
+
+## Connection Parameters
+
+```tsx
+import { createRivetKit } from "@rivetkit/react";
+
+const { useActor } = createRivetKit();
+
+function Chat() {
+  const chat = useActor({
+    name: "chatRoom",
+    key: ["general"],
+    params: { authToken: "jwt-token-here" },
+  });
+
+  return <div>{chat.connStatus}</div>;
+}
+```
+
+## Subscribing to Events
+
+```tsx
+import { createRivetKit } from "@rivetkit/react";
+
+const { useActor } = createRivetKit();
+
+function Chat() {
+  const chat = useActor({ name: "chatRoom", key: ["general"] });
+
+  chat.useEvent("message", msg => {
+    console.log("message:", msg);
+  });
+
+  return null;
+}
+```
+
+## Connection Lifecycle
+
+```tsx
+import { createRivetKit } from "@rivetkit/react";
+
+const { useActor } = createRivetKit();
+
+function CounterStatus() {
+  const actor = useActor({ name: "counter", key: ["my-counter"] });
+
+  if (actor.connStatus === "connected") {
+    console.log("connected");
+  }
+
+  if (actor.error) {
+    console.error(actor.error);
+  }
+
+  return null;
+}
+```
+
+## Low-Level HTTP & WebSocket
+
+Use the JavaScript client for raw HTTP and WebSocket access:
+
+```tsx @nocheck
+import { createClient } from "rivetkit/client";
+
+const client = createClient();
+const handle = client.chatRoom.getOrCreate(["general"]);
+
+const response = await handle.fetch("history");
+const history = await response.json();
+
+const ws = await handle.webSocket("stream");
+ws.addEventListener("message", event => {
+  console.log("message:", event.data);
+});
+ws.send("hello");
+```
+
+## Calling from Backend
+
+Use the JavaScript client on your backend (Node.js/Bun). See the [JavaScript client docs](/docs/clients/javascript).
+
+## Error Handling
+
+```tsx
+import { ActorError } from "rivetkit/client";
+import { createRivetKit } from "@rivetkit/react";
+
+const { useActor } = createRivetKit();
+
+function Profile() {
+  const actor = useActor({ name: "user", key: ["user-123"] });
+
+  const updateUsername = async () => {
+    try {
+      await actor.connection?.updateUsername("ab");
+    } catch (error) {
+      if (error instanceof ActorError) {
+        console.log(error.code, error.metadata);
+      }
+    }
+  };
+
+  return <button onClick={updateUsername}>Update</button>;
+}
+```
+
+## Concepts
+
+### Keys
+
+Keys uniquely identify actor instances. Use compound keys (arrays) for hierarchical addressing:
+
+```tsx ChatRoom.tsx
+import { createRivetKit } from "@rivetkit/react";
+import type { registry } from "./actors";
+
+const { useActor } = createRivetKit<typeof registry>();
+
+function ChatRoom() {
+  const room = useActor({ name: "chatRoom", key: ["org-acme", "general"] });
+  return <div>{room.connStatus}</div>;
+}
+```
+
+```ts actors.ts @hide
+import { actor, setup } from "rivetkit";
+
+export const chatRoom = actor({
+  state: { messages: [] as string[] },
+  actions: {
+    getRoomInfo: c => ({ org: c.key[0], room: c.key[1] }),
+  },
+});
+
+export const registry = setup({
+  use: { chatRoom },
+});
+```
+
+Don't build keys with string interpolation like `"org:${userId}"` when `userId` contains user data. Use arrays instead to prevent key injection attacks.
+
+### Environment Variables
+
+`createRivetKit()` (and the underlying `createClient()` instance) automatically read:
+
+- `RIVET_ENDPOINT`
+- `RIVET_NAMESPACE`
+- `RIVET_TOKEN`
+- `RIVET_RUNNER`
+
+Defaults to `window.location.origin + "/api/rivet"` in the browser or `http://127.0.0.1:6420` on the server when unset.
+
+### Endpoint Format
+
+Endpoints support URL auth syntax:
+
+```
+https://namespace:token@api.rivet.dev
+```
+
+You can also pass the endpoint without auth and provide `RIVET_NAMESPACE` and `RIVET_TOKEN` separately. For serverless deployments, use your app's `/api/rivet` URL. See [Endpoints](/docs/general/endpoints#url-auth-syntax) for details.
+
+## API Reference
+
+**Package:** [@rivetkit/react](https://www.npmjs.com/package/@rivetkit/react)
+
+- [`createRivetKit`](/docs/clients/react) - Create hooks for React
+- [`useActor`](/docs/clients/react) - Hook for actor instances
+
+## Need More Than the Client?
+
+If you need more about Rivet Actors, registries, or server-side RivetKit, add the main skill:
+
+```bash
+npx skills add rivet-dev/skills
+```
+
+Then use the `rivetkit` skill for backend guidance.

package/vendor/skills/skills/rivetkit-client-react/index.json

@@ -0,0 +1,7 @@
+{
+    "name": "rivetkit-client-react",
+    "description": "RivetKit React client guidance. Use for React apps that connect to Rivet Actors with @rivetkit/react, create hooks with createRivetKit, or manage realtime state with useActor.",
+    "skill_url": "/metadata/skills/rivetkit-client-react/SKILL.md",
+    "generated_at": "2026-02-24T11:03:05.833Z",
+    "references": []
+}