@slopware/sloppy-darwin-x64 0.1.0-alpha.0

package/examples/prealpha-control-plane/README.md

@@ -0,0 +1,50 @@
+# Pre-alpha control plane
+
+This is a multi-file contributor/internal example for the current Sloppy
+app-host and source-input path. It models a small deployment control plane with
+projects, apps, builds, deployments, diagnostics, health routes, and a SQLite
+provider.
+
+The example is intentionally plain JavaScript source with no `package.json`.
+No npm package scope is required. The compiler resolves `"sloppy"` and relative
+imports from the project root.
+
+## What it covers
+
+- `sloppy build` and `sloppy run` project-mode dogfood through `sloppy.json`.
+- Function modules registered through `app.useModule(...)`.
+- Route groups, named routes, path params, query params, JSON request bodies,
+  `Results.created`, `Results.badRequest`, and `Results.notFound`.
+- SQLite provider metadata and the `data.main` capability in emitted plans.
+- App test host dispatch against the same route modules in
+  `tests/bootstrap/test_prealpha_control_plane_dogfood.mjs`.
+
+## Current coverage
+
+Default non-V8 lanes compile the project and verify that `sloppy run` emits
+artifacts before reporting the required V8 diagnostic. The V8-gated lane runs:
+
+```powershell
+sloppy run --once GET /projects?owner=runtime
+```
+
+from this directory and expects the seeded `Compiler Platform` project in the
+response.
+
+The app test host lane also verifies CORS preflight, request IDs, request
+logging redaction, ProblemDetails redaction, request service-scope disposal,
+health routes, method mismatch, not-found behavior, and host lifecycle cleanup.
+
+## Current limits
+
+This example stays inside the syntax that `sloppyc` can extract today. Source
+root imports therefore use `Sloppy`, `ProblemDetails`, and
+`sloppy/providers/sqlite`; route modules import `Results` in the files that
+call `Results.*`. Request-id middleware, request logging middleware, and
+`app.mapHealthChecks()` are covered by the app test host rather than by the
+compiled source project.
+
+The source route modules keep SQL near the handlers because current function
+module extraction does not support arbitrary helper calls inside module files.
+The `src/services`, `src/db`, and `src/validation` folders document the intended
+bounded-context layout without being imported by the compiled app yet.

package/examples/prealpha-control-plane/appsettings.Development.json

@@ -0,0 +1,11 @@
+{
+  "Sloppy": {
+    "Providers": {
+      "sqlite": {
+        "main": {
+          "database": "prealpha-control-plane-dev.db"
+        }
+      }
+    }
+  }
+}

package/examples/prealpha-control-plane/appsettings.json

@@ -0,0 +1,15 @@
+{
+  "Sloppy": {
+    "Providers": {
+      "sqlite": {
+        "main": {
+          "database": "prealpha-control-plane.db"
+        }
+      }
+    }
+  },
+  "ControlPlane": {
+    "corsOrigin": "https://console.example",
+    "environment": "dogfood"
+  }
+}

package/examples/prealpha-control-plane/sloppy.json

@@ -0,0 +1,5 @@
+{
+  "entry": "src/main.js",
+  "outDir": ".sloppy",
+  "environment": "Development"
+}

package/examples/prealpha-control-plane/src/db/schema.js

@@ -0,0 +1,7 @@
+export const schemaStatements = Object.freeze([
+    "create table if not exists projects (id integer primary key, slug text not null unique, name text not null, owner text not null)",
+    "create table if not exists apps (id integer primary key, project_id integer not null, name text not null, environment text not null)",
+    "create table if not exists builds (id integer primary key, app_id integer not null, commit_sha text not null, status text not null)",
+    "create table if not exists deployments (id integer primary key, app_id integer not null, build_id integer not null, status text not null)",
+    "create table if not exists diagnostics (id integer primary key, level text not null, message text not null)",
+]);

package/examples/prealpha-control-plane/src/db/seed.js

@@ -0,0 +1,6 @@
+export const seedSummary = Object.freeze({
+    projects: 2,
+    apps: 2,
+    builds: 1,
+    diagnostics: 1,
+});

package/examples/prealpha-control-plane/src/main.js

@@ -0,0 +1,21 @@
+import { ProblemDetails, Sloppy } from "sloppy";
+import { sqlite } from "sloppy/providers/sqlite";
+import { appsModule } from "./routes/apps.js";
+import { buildsModule } from "./routes/builds.js";
+import { deploymentsModule } from "./routes/deployments.js";
+import { diagnosticsModule } from "./routes/diagnostics.js";
+import { healthModule } from "./routes/health.js";
+import { projectsModule } from "./routes/projects.js";
+
+const app = Sloppy.create();
+
+app.use(ProblemDetails.defaults());
+app.use(sqlite("main", { database: "prealpha-control-plane.db" }));
+app.useModule(healthModule);
+app.useModule(projectsModule);
+app.useModule(appsModule);
+app.useModule(buildsModule);
+app.useModule(deploymentsModule);
+app.useModule(diagnosticsModule);
+
+export default app;

package/examples/prealpha-control-plane/src/routes/apps.js

@@ -0,0 +1,34 @@
+import { Results } from "sloppy";
+
+export function appsModule(app) {
+    const db = app.provider("sqlite:main");
+    const apps = app.group("/apps");
+
+    apps.get("/", async () => {
+        await db.exec("create table if not exists apps (id integer primary key, project_id integer not null, name text not null, environment text not null)", []);
+        await db.exec("insert into apps (id, project_id, name, environment) select ?, ?, ?, ? where not exists (select 1 from apps where id = ?)", [1, 1, "compiler-api", "Development", 1]);
+        await db.exec("insert into apps (id, project_id, name, environment) select ?, ?, ?, ? where not exists (select 1 from apps where id = ?)", [2, 2, "control-plane", "Development", 2]);
+        return Results.ok(await db.query("select id, project_id, name, environment from apps order by id", []));
+    }).withName("Apps.List");
+
+    apps.post("/", async (ctx) => {
+        const body = ctx.request.json();
+        if (body === null || Array.isArray(body) || typeof body !== "object" ||
+            typeof body.name !== "string" || body.name.length === 0 ||
+            !Number.isInteger(body.projectId) || body.projectId <= 0) {
+            return Results.badRequest({ code: "APP_INVALID", message: "projectId and name are required" });
+        }
+
+        await db.exec("create table if not exists apps (id integer primary key, project_id integer not null, name text not null, environment text not null)", []);
+        await db.exec("insert into apps (project_id, name, environment) values (?, ?, ?)", [body.projectId, body.name, body.environment ?? "Development"]);
+        const created = await db.queryOne("select id, project_id, name, environment from apps where id = last_insert_rowid()", []);
+        return Results.created(`/apps/${created.id}`, created);
+    }).withName("Apps.Create");
+
+    apps.get("/{id:int}", async (ctx) => {
+        await db.exec("create table if not exists apps (id integer primary key, project_id integer not null, name text not null, environment text not null)", []);
+        await db.exec("insert into apps (id, project_id, name, environment) select ?, ?, ?, ? where not exists (select 1 from apps where id = ?)", [1, 1, "compiler-api", "Development", 1]);
+        const current = await db.queryOne("select id, project_id, name, environment from apps where id = ?", [ctx.route.id]);
+        return current === null ? Results.notFound({ code: "APP_NOT_FOUND" }) : Results.ok(current);
+    }).withName("Apps.Get");
+}

package/examples/prealpha-control-plane/src/routes/builds.js

@@ -0,0 +1,25 @@
+import { Results } from "sloppy";
+
+export function buildsModule(app) {
+    const db = app.provider("sqlite:main");
+    const apps = app.group("/apps");
+
+    apps.post("/{id:int}/builds", async (ctx) => {
+        const body = ctx.request.json();
+        if (body === null || Array.isArray(body) || typeof body !== "object" ||
+            typeof body.commit !== "string" || body.commit.length === 0) {
+            return Results.badRequest({ code: "BUILD_INVALID", message: "commit is required" });
+        }
+
+        await db.exec("create table if not exists builds (id integer primary key, app_id integer not null, commit_sha text not null, status text not null)", []);
+        await db.exec("insert into builds (app_id, commit_sha, status) values (?, ?, ?)", [ctx.route.id, body.commit, "queued"]);
+        const build = await db.queryOne("select id, app_id, commit_sha, status from builds where id = last_insert_rowid()", []);
+        return Results.created(`/apps/${ctx.route.id}/builds/${build.id}`, build);
+    }).withName("Builds.Create");
+
+    apps.get("/{id:int}/builds", async (ctx) => {
+        await db.exec("create table if not exists builds (id integer primary key, app_id integer not null, commit_sha text not null, status text not null)", []);
+        await db.exec("insert into builds (id, app_id, commit_sha, status) select ?, ?, ?, ? where not exists (select 1 from builds where id = ?)", [1, ctx.route.id, "abc123", "succeeded", 1]);
+        return Results.ok(await db.query("select id, app_id, commit_sha, status from builds where app_id = ? order by id", [ctx.route.id]));
+    }).withName("Builds.List");
+}

package/examples/prealpha-control-plane/src/routes/deployments.js

@@ -0,0 +1,19 @@
+import { Results } from "sloppy";
+
+export function deploymentsModule(app) {
+    const db = app.provider("sqlite:main");
+    const apps = app.group("/apps");
+
+    apps.post("/{id:int}/deployments", async (ctx) => {
+        const body = ctx.request.json();
+        if (body === null || Array.isArray(body) || typeof body !== "object" ||
+            !Number.isInteger(body.buildId) || body.buildId <= 0) {
+            return Results.badRequest({ code: "DEPLOYMENT_INVALID", message: "buildId is required" });
+        }
+
+        await db.exec("create table if not exists deployments (id integer primary key, app_id integer not null, build_id integer not null, status text not null)", []);
+        await db.exec("insert into deployments (app_id, build_id, status) values (?, ?, ?)", [ctx.route.id, body.buildId, "started"]);
+        const deployment = await db.queryOne("select id, app_id, build_id, status from deployments where id = last_insert_rowid()", []);
+        return Results.created(`/apps/${ctx.route.id}/deployments/${deployment.id}`, deployment);
+    }).withName("Deployments.Create");
+}

package/examples/prealpha-control-plane/src/routes/diagnostics.js

@@ -0,0 +1,11 @@
+import { Results } from "sloppy";
+
+export function diagnosticsModule(app) {
+    const db = app.provider("sqlite:main");
+
+    app.get("/diagnostics/recent", async () => {
+        await db.exec("create table if not exists diagnostics (id integer primary key, level text not null, message text not null)", []);
+        await db.exec("insert into diagnostics (id, level, message) select ?, ?, ? where not exists (select 1 from diagnostics where id = ?)", [1, "info", "dogfood app bootstrapped", 1]);
+        return Results.ok(await db.query("select id, level, message from diagnostics order by id desc", []));
+    }).withName("Diagnostics.Recent");
+}

package/examples/prealpha-control-plane/src/routes/health.js

@@ -0,0 +1,27 @@
+import { Results } from "sloppy";
+
+export function healthModule(app) {
+    const health = app.group("/health");
+
+    health.get("/", () => Results.ok({
+        status: "healthy",
+        checks: [
+            { name: "sqlite", status: "healthy" },
+            { name: "app-host", status: "healthy" },
+        ],
+    })).withName("Health");
+
+    health.get("/live", () => Results.ok({
+        status: "healthy",
+        checks: [
+            { name: "process", status: "healthy" },
+        ],
+    })).withName("Health.Liveness");
+
+    health.get("/ready", () => Results.ok({
+        status: "healthy",
+        checks: [
+            { name: "sqlite", status: "healthy" },
+        ],
+    })).withName("Health.Readiness");
+}

package/examples/prealpha-control-plane/src/routes/projects.js

@@ -0,0 +1,38 @@
+import { Results } from "sloppy";
+
+export function projectsModule(app) {
+    const db = app.provider("sqlite:main");
+    const projects = app.group("/projects");
+
+    projects.get("/", async (ctx) => {
+        await db.exec("create table if not exists projects (id integer primary key, slug text not null unique, name text not null, owner text not null)", []);
+        await db.exec("insert into projects (id, slug, name, owner) select ?, ?, ?, ? where not exists (select 1 from projects where id = ?)", [1, "compiler", "Compiler Platform", "runtime", 1]);
+        await db.exec("insert into projects (id, slug, name, owner) select ?, ?, ?, ? where not exists (select 1 from projects where id = ?)", [2, "web", "Web Framework", "framework", 2]);
+        const owner = ctx.query.owner;
+        if (owner !== undefined) {
+            return Results.ok(await db.query("select id, slug, name, owner from projects where owner = ? order by id", [owner]));
+        }
+        return Results.ok(await db.query("select id, slug, name, owner from projects order by id", []));
+    }).withName("Projects.List");
+
+    projects.post("/", async (ctx) => {
+        const body = ctx.request.json();
+        if (body === null || Array.isArray(body) || typeof body !== "object" ||
+            typeof body.slug !== "string" || body.slug.length === 0 ||
+            typeof body.name !== "string" || body.name.length === 0) {
+            return Results.badRequest({ code: "PROJECT_INVALID", message: "slug and name are required" });
+        }
+
+        await db.exec("create table if not exists projects (id integer primary key, slug text not null unique, name text not null, owner text not null)", []);
+        await db.exec("insert into projects (slug, name, owner) values (?, ?, ?)", [body.slug, body.name, body.owner ?? "platform"]);
+        const project = await db.queryOne("select id, slug, name, owner from projects where slug = ?", [body.slug]);
+        return Results.created(`/projects/${project.id}`, project);
+    }).withName("Projects.Create");
+
+    projects.get("/{id:int}", async (ctx) => {
+        await db.exec("create table if not exists projects (id integer primary key, slug text not null unique, name text not null, owner text not null)", []);
+        await db.exec("insert into projects (id, slug, name, owner) select ?, ?, ?, ? where not exists (select 1 from projects where id = ?)", [1, "compiler", "Compiler Platform", "runtime", 1]);
+        const project = await db.queryOne("select id, slug, name, owner from projects where id = ?", [ctx.route.id]);
+        return project === null ? Results.notFound({ code: "PROJECT_NOT_FOUND" }) : Results.ok(project);
+    }).withName("Projects.Get");
+}

package/examples/prealpha-control-plane/src/services/diagnosticsSink.js

@@ -0,0 +1,11 @@
+export function createDiagnosticsSink() {
+    const entries = [];
+    return Object.freeze({
+        push(entry) {
+            entries.push(Object.freeze({ ...entry }));
+        },
+        recent() {
+            return Object.freeze(entries.slice().reverse());
+        },
+    });
+}

package/examples/prealpha-control-plane/src/services/repositories.js

@@ -0,0 +1,9 @@
+export function repositoryTokens() {
+    return Object.freeze([
+        "projects",
+        "apps",
+        "builds",
+        "deployments",
+        "diagnostics",
+    ]);
+}

package/examples/prealpha-control-plane/src/validation/schemas.js

@@ -0,0 +1,6 @@
+export const validationShapes = Object.freeze({
+    projectCreate: ["slug", "name"],
+    appCreate: ["projectId", "name"],
+    buildCreate: ["commit"],
+    deploymentCreate: ["buildId"],
+});

package/examples/program-fs-process/README.md

@@ -0,0 +1,31 @@
+# Program Filesystem And Process
+
+Program Mode can use the Sloppy stdlib without declaring a web app. This
+example writes a small file, reads it back, and runs `git --version` through
+`Process.run`.
+
+Prerequisite: `git` must be installed and available on `PATH` for the
+`Process.run("git", ["--version"])` call.
+
+Run from this directory with a V8-enabled build:
+
+```powershell
+sloppy run -- report
+```
+
+Build and run the artifacts:
+
+```powershell
+sloppy build
+sloppy run .sloppy -- report
+```
+
+Package and run from the package directory:
+
+```powershell
+sloppy package
+sloppy run .sloppy/package -- report
+```
+
+The example writes under `./tmp`. It uses `sloppy/fs` and `sloppy/os`; it does
+not use Node `fs`, `process`, or `child_process` globals.

package/examples/program-fs-process/sloppy.json

@@ -0,0 +1,9 @@
+{
+  "kind": "program",
+  "entry": "src/main.ts",
+  "outDir": ".sloppy",
+  "capabilities": {
+    "fs": true,
+    "os": true
+  }
+}

package/examples/program-fs-process/src/main.ts

@@ -0,0 +1,27 @@
+import { Directory, File } from "sloppy/fs";
+import { Process, System } from "sloppy/os";
+
+function sanitizeFilename(value) {
+    const text = String(value || "report")
+        .replace(/[^A-Za-z0-9_-]/g, "_")
+        .slice(0, 64);
+    return text.length > 0 ? text : "report";
+}
+
+export async function main(args, ctx) {
+    const name = sanitizeFilename(args[0]);
+    const path = `./tmp/${name}.txt`;
+
+    await Directory.create("./tmp", { recursive: true });
+    await File.writeText(path, `kind=${ctx.kind}\nplatform=${System.platform}\n`);
+
+    const text = await File.readText(path);
+    const git = await Process.run("git", ["--version"], {
+        capture: "text",
+        timeoutMs: 5000,
+    });
+
+    console.log(text.trim());
+    console.log(git.stdout.trim());
+    return git.exitCode;
+}

package/examples/program-hello/README.md

@@ -0,0 +1,32 @@
+# Program Hello
+
+Minimal Program Mode source. It does not declare a web app or routes; the
+compiler emits a Program Plan with an opaque metadata status and a
+`__sloppy_program_main` entrypoint.
+
+Run the source directly when using a V8-enabled build:
+
+```powershell
+sloppy run main.ts -- Ada
+```
+
+Build and inspect the generated artifacts:
+
+```powershell
+sloppy build main.ts
+sloppy run .sloppy -- Ada
+sloppy routes .sloppy --format json
+sloppy capabilities .sloppy
+```
+
+`sloppy.json` is optional project pinning for this example. From this directory,
+the same project can be built with:
+
+```powershell
+sloppy build
+sloppy run .sloppy -- Ada
+```
+
+Program execution requires a V8-enabled build. In a default non-V8 developer
+build, `sloppy run main.ts -- Ada` and `sloppy run .sloppy -- Ada` fail before V8
+initialization with a required-feature diagnostic.

package/examples/program-hello/main.ts

@@ -0,0 +1,8 @@
+import { message } from "./message";
+
+export function main(args, ctx) {
+    const suffix = args.length > 0 ? ` ${args.join(" ")}` : "";
+    console.log(`${message}${suffix}`);
+    console.log(`cwd=${ctx.cwd}`);
+    return 0;
+}

package/examples/program-hello/message.ts

@@ -0,0 +1 @@
+export const message = "hello from sloppy program mode";

package/examples/program-hello/sloppy.json

@@ -0,0 +1,5 @@
+{
+  "kind": "program",
+  "entry": "main.ts",
+  "outDir": ".sloppy"
+}

package/examples/rate-limit-auth/README.md

@@ -0,0 +1,3 @@
+# Rate Limit Auth
+
+Shows a token-bucket limiter partitioned by authenticated user.

package/examples/rate-limit-auth/app.js

@@ -0,0 +1,14 @@
+import { RateLimit, Results, Sloppy } from "sloppy";
+
+const app = Sloppy.create();
+
+app.get("/me", (ctx) => Results.ok({ sub: ctx.user.sub }))
+  .requiresAuth()
+  .rateLimit(RateLimit.tokenBucket({
+    name: "me",
+    capacity: 100,
+    refillPerSecond: 10,
+    partitionBy: RateLimit.partition.user(),
+  }));
+
+export default app;

package/examples/rate-limit-basic/README.md

@@ -0,0 +1,3 @@
+# Rate Limit Basic
+
+Protects a public login route with a sliding-window IP limiter.

package/examples/rate-limit-basic/app.js

@@ -0,0 +1,13 @@
+import { RateLimit, Results, Sloppy } from "sloppy";
+
+const app = Sloppy.create();
+
+app.post("/login", () => Results.ok({ ok: true }))
+  .rateLimit(RateLimit.slidingWindow({
+    name: "login",
+    limit: 5,
+    windowMs: 60_000,
+    partitionBy: RateLimit.partition.ip(),
+  }));
+
+export default app;

package/examples/rate-limit-redis/README.md

@@ -0,0 +1,5 @@
+# Rate Limit Redis
+
+Demonstrates the distributed-store registration shape. This build does not
+include a first-party Redis provider, so the adapter fails closed instead of
+falling back to memory.

package/examples/rate-limit-redis/app.js

@@ -0,0 +1,20 @@
+import { RateLimit, Results, Sloppy } from "sloppy";
+
+const app = Sloppy.create();
+
+const redisStore = RateLimit.redis(undefined, {
+  prefix: "sloppy:rl:",
+});
+
+app.services.addRateLimitStore("redis", redisStore);
+
+app.post("/login", () => Results.ok({ ok: true }))
+  .rateLimit(RateLimit.slidingWindow({
+    name: "login",
+    limit: 5,
+    windowMs: 60_000,
+    store: "redis",
+    partitionBy: RateLimit.partition.ip(),
+  }));
+
+export default app;

package/examples/rate-limit-testhost/README.md

@@ -0,0 +1,4 @@
+# Rate Limit TestHost
+
+Use `TestHost.create(app, { clock, rateLimit: { stores } })` to isolate stores
+and drive windows with a fake clock.

package/examples/rate-limit-testhost/app.js

@@ -0,0 +1,13 @@
+import { RateLimit, Results, Sloppy } from "sloppy";
+
+const app = Sloppy.create();
+
+app.get("/limited", () => Results.ok({ ok: true }))
+  .rateLimit(RateLimit.fixedWindow({
+    name: "test",
+    limit: 1,
+    windowMs: 1000,
+    partitionBy: RateLimit.partition.ip(),
+  }));
+
+export default app;

package/examples/rate-limit-websocket/README.md

@@ -0,0 +1,3 @@
+# Rate Limit WebSocket
+
+Applies a fixed-window limiter to WebSocket upgrade attempts.

package/examples/rate-limit-websocket/app.js

@@ -0,0 +1,16 @@
+import { RateLimit, Sloppy } from "sloppy";
+
+const app = Sloppy.create();
+
+app.websocket("/ws", async (socket) => {
+  await socket.accept();
+  await socket.sendText("connected");
+})
+  .rateLimit(RateLimit.fixedWindow({
+    name: "ws-connect",
+    limit: 10,
+    windowMs: 60_000,
+    partitionBy: RateLimit.partition.ip(),
+  }));
+
+export default app;

package/examples/realtime-auth/README.md

@@ -0,0 +1,8 @@
+# Realtime Auth
+
+Realtime auth example covering route-level auth, origin policy, and
+per-message role checks.
+
+```powershell
+node examples/realtime-auth/test.mjs
+```

package/examples/realtime-auth/app.js

@@ -0,0 +1,25 @@
+import { Realtime, Sloppy, schema } from "sloppy";
+
+export const SecureChannel = Realtime.channel("secureChat", {
+    client: {
+        adminMessage: Realtime.event(schema.object({
+            text: schema.string(),
+        })).requiresRole("admin"),
+    },
+    server: {
+        accepted: schema.object({
+            text: schema.string(),
+        }),
+    },
+});
+
+const app = Sloppy.create();
+
+app.realtime("/secure/chat", SecureChannel, async (ctx) => {
+    await ctx.accept();
+    ctx.on("adminMessage", async (input) => {
+        await ctx.send("accepted", { text: input.text });
+    });
+}).requiresAuth().requiresScope("chat").allowedOrigins(["https://app.example.com"]);
+
+export default app;

package/examples/realtime-auth/test.mjs

@@ -0,0 +1,43 @@
+import { Realtime, Sloppy, TestHost, schema } from "sloppy";
+
+const SecureChannel = Realtime.channel("secureChat", {
+    client: {
+        adminMessage: Realtime.event(schema.object({
+            text: schema.string(),
+        })).requiresRole("admin"),
+    },
+    server: {
+        accepted: schema.object({
+            text: schema.string(),
+        }),
+    },
+});
+
+const app = Sloppy.create();
+
+app.realtime("/secure/chat", SecureChannel, async (ctx) => {
+    await ctx.accept();
+    ctx.on("adminMessage", async (input) => {
+        await ctx.send("accepted", { text: input.text });
+    });
+}).requiresAuth().requiresScope("chat").allowedOrigins(["https://app.example.com"]);
+
+const host = await TestHost.create(app);
+
+try {
+    await host.realtime("/secure/chat", SecureChannel)
+        .origin("https://app.example.com")
+        .connect()
+        .expectRejected(401);
+
+    const writer = await host.realtime("/secure/chat", SecureChannel)
+        .origin("https://app.example.com")
+        .asUser({ sub: "writer", scopes: ["chat"], roles: ["admin"] })
+        .connect();
+
+    await writer.send("adminMessage", { text: "approved" });
+    await writer.expect("accepted", { text: "approved" });
+    await writer.close();
+} finally {
+    await host.close();
+}

package/examples/realtime-chat/README.md

@@ -0,0 +1,8 @@
+# Realtime Chat
+
+Typed chat room example using `app.realtime(...)`, a `Realtime.channel(...)`,
+single-process groups, route auth, and TestHost clients.
+
+```powershell
+node examples/realtime-chat/test.mjs
+```