@mediamonks/canopy-cli 0.7.27 → 0.7.29

package/dist/{db-DVMwCLlU.mjs → db-KTLn8J1u.mjs}

@@ -1,6 +1,6 @@
 import { c as resolveProject, o as projectFlagArgs } from "./site-DM2J10CB.mjs";
-import { a as unwrap, d as withContext, i as requireTty, l as apiRequest, r as reportErrors, s as apiDataRequest } from "./ui-DR-siu2S.mjs";
-import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-B9fXxMDj.mjs";
+import { a as unwrap, d as withContext, i as requireTty, l as apiRequest, r as reportErrors, s as apiDataRequest } from "./ui-CeupNHNa.mjs";
+import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-C8yRPJIX.mjs";
 import { defineCommand } from "citty";
 import { readFileSync, writeFileSync } from "node:fs";
 import * as p from "@clack/prompts";

package/dist/{deploy-CTMcwHhI.mjs → deploy-CBf44bvG.mjs}

@@ -1,6 +1,6 @@
 import { a as projectDirArgs, c as resolveProject, l as stagingUrl, n as siteConfig, o as projectFlagArgs, s as projectUrl, u as tryReadCanopyJson } from "./site-DM2J10CB.mjs";
-import { a as unwrap, c as apiDownload, d as withContext, l as apiRequest, r as reportErrors, s as apiDataRequest, t as formatDateTime } from "./ui-DR-siu2S.mjs";
-import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-B9fXxMDj.mjs";
+import { a as unwrap, c as apiDownload, d as withContext, l as apiRequest, r as reportErrors, s as apiDataRequest, t as formatDateTime } from "./ui-CeupNHNa.mjs";
+import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-C8yRPJIX.mjs";
 import { defineCommand } from "citty";
 import { mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";

package/dist/dev-DGCu9MjB.mjs

@@ -0,0 +1,2 @@
+import { n as devCommand } from "./dev-JlzMZJow.mjs";
+export { devCommand };

package/dist/{dev-BvjbJcse.mjs → dev-JlzMZJow.mjs}

@@ -1,7 +1,7 @@
 import { a as projectDirArgs, c as resolveProject, i as projectDialect, n as siteConfig, u as tryReadCanopyJson } from "./site-DM2J10CB.mjs";
-import { d as withContext, l as apiRequest, o as ApiError, r as reportErrors, t as formatDateTime } from "./ui-DR-siu2S.mjs";
-import { r as readMigrationFiles } from "./migrations-B9fXxMDj.mjs";
-import { n as stampWorkerHeaders } from "./src-CwSKZwNK.mjs";
+import { d as withContext, l as apiRequest, o as ApiError, r as reportErrors, t as formatDateTime } from "./ui-CeupNHNa.mjs";
+import { r as readMigrationFiles } from "./migrations-C8yRPJIX.mjs";
+import { n as stampWorkerHeaders } from "./src-C7zPhbxi.mjs";
 import { createRequire } from "node:module";
 import { defineCommand } from "citty";
 import { existsSync } from "node:fs";
@@ -38,7 +38,7 @@ async function workerPlugin(flags, slug) {
 		console.log(`note: canopy.json points "worker" at ${entry}, which does not exist — skipping.`);
 		return;
 	}
-	const { missingSecretNames, readDevVars, workerDevPlugin } = await import("./dev-worker-BerdPJ_U.mjs");
+	const { missingSecretNames, readDevVars, workerDevPlugin } = await import("./dev-worker-DjJGSUGj.mjs");
 	const secrets = readDevVars(flags.dir);
 	const email = siteConfig().email;
 	const plugin = workerDevPlugin({
@@ -146,6 +146,48 @@ function devProxyHeaders(token, slug, channel) {
 	});
 	return Object.fromEntries(headers);
 }
+/**
+* One request from Vite's /_api proxy into the --local sandbox. The response
+* body is streamed, not buffered — realtime subscriptions (docs/48) are
+* long-lived SSE responses — and a client that goes away aborts the sandbox
+* request and cancels its body, so the subscription is released.
+*/
+async function bridgeToSandbox(sandbox, req, res) {
+	const gone = new AbortController();
+	res.on("close", () => gone.abort());
+	const chunks = [];
+	for await (const chunk of req) chunks.push(chunk);
+	const body = Buffer.concat(chunks);
+	const headers = new Headers();
+	if (req.headers["content-type"]) headers.set("content-type", req.headers["content-type"]);
+	if (req.headers["accept"]) headers.set("accept", req.headers["accept"]);
+	const response = await sandbox.handle(new Request(`http://canopy.local${req.url ?? ""}`, {
+		method: req.method,
+		headers,
+		body: body.length === 0 ? void 0 : new Uint8Array(body),
+		signal: gone.signal
+	}));
+	if (gone.signal.aborted) {
+		await response.body?.cancel().catch(() => {});
+		return;
+	}
+	res.writeHead(response.status, Object.fromEntries(response.headers));
+	if (!response.body) {
+		res.end();
+		return;
+	}
+	const reader = response.body.getReader();
+	gone.signal.addEventListener("abort", () => void reader.cancel().catch(() => {}), { once: true });
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			res.write(value);
+		}
+	} catch {} finally {
+		res.end();
+	}
+}
 async function devRemote(flags, slug) {
 	const { token, expires_at } = await withContext(apiRequest("POST", `/projects/${slug}/dev-token`), devTokenContext(slug));
 	const { apiUrl } = siteConfig();
@@ -176,7 +218,7 @@ async function devRemote(flags, slug) {
 async function devLocal(flags, slug) {
 	let dump;
 	if (flags.pull) {
-		const { fetchProjectDump } = await import("./local-laAZEDVJ.mjs");
+		const { fetchProjectDump } = await import("./local-BA_TPWpN.mjs");
 		console.log(`Pulling a fresh export of ${slug}${flags.staging ? " [staging]" : ""}…`);
 		dump = await fetchProjectDump(slug, flags.staging ? "staging" : "live");
 	}
@@ -191,7 +233,7 @@ async function devLocal(flags, slug) {
 		const reason = err instanceof ApiError ? err.explain().why : String(err);
 		console.log(`Note: ai/services will be unavailable — could not reach the platform (${reason}).`);
 	}
-	const { createSandbox } = await import("./local-laAZEDVJ.mjs");
+	const { createSandbox } = await import("./local-BA_TPWpN.mjs");
 	const sandbox = await createSandbox({
 		slug,
 		persistDir: join(flags.dir, ".canopy", "local"),
@@ -207,20 +249,7 @@ async function devLocal(flags, slug) {
 		const { applied } = await sandbox.applyMigrations(migrationFiles);
 		if (applied.length > 0) console.log(`Applied ${applied.length} pending migration(s): ${applied.join(", ")}`);
 	}
-	const handleApi = async (req, res) => {
-		const chunks = [];
-		for await (const chunk of req) chunks.push(chunk);
-		const body = Buffer.concat(chunks);
-		const headers = new Headers();
-		if (req.headers["content-type"]) headers.set("content-type", req.headers["content-type"]);
-		const response = await sandbox.handle(new Request(`http://canopy.local${req.url ?? ""}`, {
-			method: req.method,
-			headers,
-			body: body.length === 0 ? void 0 : new Uint8Array(body)
-		}));
-		res.writeHead(response.status, Object.fromEntries(response.headers));
-		res.end(Buffer.from(await response.arrayBuffer()));
-	};
+	const handleApi = (req, res) => bridgeToSandbox(sandbox, req, res);
 	const { createServer: createHttpServer } = await import("node:http");
 	const apiServer = createHttpServer((req, res) => {
 		handleApi(req, res).catch((err) => {
@@ -312,4 +341,4 @@ const devCommand = defineCommand({
 	})
 });
 //#endregion
-export { devProxyHeaders as n, rewriteApiPath as r, devCommand as t };
+export { rewriteApiPath as i, devCommand as n, devProxyHeaders as r, bridgeToSandbox as t };

package/dist/{dev-worker-BerdPJ_U.mjs → dev-worker-DjJGSUGj.mjs}

@@ -1,4 +1,4 @@
-import { n as stampWorkerHeaders, t as redactCanopyCredentials } from "./src-CwSKZwNK.mjs";
+import { n as stampWorkerHeaders, t as redactCanopyCredentials } from "./src-C7zPhbxi.mjs";
 import { readFileSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
 //#region src/dev-worker.ts

package/dist/docs/cli-db.md

@@ -53,6 +53,8 @@ Behavior:
 2. Unless `--yes` is passed, it asks you to **type the project slug** to confirm — a deliberate speed bump, since restore is destructive. A non-TTY without `--yes` errors instead of guessing.
 3. The chosen snapshot or file replaces the entire database, and the CLI confirms `Restored <slug>.`
 
+A dump only restores into a database of the same kind. Feeding a dump from a SQLite-based project to a Postgres-based one (or the other way round) is refused up front with `dump_dialect_mismatch`, before anything is wiped. Check with `canopy db pull` on both sides: a SQLite dump opens with a `PRAGMA` line, a Postgres dump with a `-- Canopy project dump (postgres)` banner. For a project that uses **document collections only**, the collection table has the same layout everywhere, so deleting that leading `PRAGMA` line makes a SQLite dump restore on Postgres. Custom tables need their column types adapted by hand.
+
 ### canopy db migrate
 
 Applies pending schema migrations to the project's **live** database, without deploying. Requires a `"migrations"` directory in `canopy.json` (for example your `drizzle-kit generate` output — see the [migrations guide](https://docs.canopy.website/guides/migrations)).

package/dist/docs/cli-index.md

@@ -7,7 +7,7 @@ Everything on Canopy is driven by one command-line tool: `canopy`. It scaffolds
 
 ## Install
 
-The CLI is published on npm as `@mediamonks/canopy-cli`. You need Node.js 20 or newer; then install it globally:
+The CLI is published on npm as `@mediamonks/canopy-cli`. You need Node.js 24 or newer; then install it globally:
 
 ```bash
 npm install -g @mediamonks/canopy-cli

package/dist/docs/getting-started.md

@@ -24,7 +24,7 @@ Confirm it's on your PATH:
 canopy --version
 ```
 
-If `npm` isn't available, install Node.js 20+ first (https://nodejs.org), then
+If `npm` isn't available, install Node.js 24+ first (https://nodejs.org), then
 re-run the install.
 
 ## 2. Sign in

package/dist/docs/index.json

@@ -306,12 +306,12 @@
     {
       "key": "sdk",
       "title": "SDK reference",
-      "description": "The typed client your project code uses — auth, data, files, AI, services.",
+      "description": "The typed client your project code uses — auth, data, files, AI, email, notify, realtime, services.",
       "topics": [
         {
           "slug": "sdk",
           "title": "Using the SDK",
-          "summary": "One typed client for auth, data, files, AI, email, and services — no keys, no connection strings, the platform authenticates for you."
+          "summary": "One typed client for auth, data, files, AI, email, notify, realtime, and services — no keys, no connection strings, the platform authenticates for you."
         },
         {
           "slug": "sdk-auth",
@@ -338,6 +338,16 @@
           "title": "Email",
           "summary": "Send email from your project without a mail server or an API key — Monks recipients only, with a per-project daily quota and a sent log."
         },
+        {
+          "slug": "sdk-notify",
+          "title": "Notify",
+          "summary": "Post a Slack message from your project through the Canopy bot — to your linked channels or a colleague's DMs — with nothing to set up."
+        },
+        {
+          "slug": "sdk-realtime",
+          "title": "Realtime",
+          "summary": "Live updates between the people using your app — subscribe to a topic, publish to it, no backend needed."
+        },
         {
           "slug": "sdk-google",
           "title": "Google",

package/dist/docs/platform-egress.md

@@ -112,6 +112,31 @@ Switching back is one command (`canopy egress mode allowlist`), and the
 dashboard offers to **seed the allowlist from the observed hosts** so
 tightening up later doesn't break the app.
 
+## Allowlisting Canopy on the other side
+
+Some external services only accept calls from IP addresses you register with
+them first — a partner API, a corporate database, a payment provider's
+allowlist. Projects hosted on **Google Cloud** (the `gcp-pilot` site,
+`canopy.monks.zone`) make every outbound request from a fixed pair of
+addresses, so you can hand them over:
+
+| Address          |
+| ---------------- |
+| `34.187.107.103` |
+| `34.158.168.43`  |
+
+Register **both**. Traffic may leave from either one, and the second gives the
+platform room to grow without asking you to update your allowlist. These
+addresses are shared by every project on that site, so registering them lets
+any Canopy project on Google Cloud reach the service — the other service's own
+authentication (API keys, tokens) still decides who gets in.
+
+The addresses are a platform commitment: they will not change without notice
+and a migration period. Projects hosted on Cloudflare have **no** fixed
+outbound address (requests leave from Cloudflare's shared edge), so if a
+service you depend on insists on IP allowlisting, run that project on the
+Google Cloud site.
+
 ## The outbound traffic log
 
 In both modes, the platform keeps a per-project log of the hosts the worker

package/dist/docs/platform-members-and-access.md

@@ -35,10 +35,19 @@ nobody outside the team can touch its data or settings.
 
 ## Inviting collaborators
 
-Open the project's **Settings** tab and use the **Collaborators** card. A
-searchable people picker finds anyone who has signed in to Canopy; adding
-them takes effect immediately. Owners (and admins) can also remove people
-from the same card.
+Open the project's **Settings** tab and use the **Collaborators** card. Start
+typing a name or email: colleagues who have signed in to Canopy before show up
+as suggestions, and picking one adds them immediately.
+
+Someone who has never opened Canopy can be added too — type their full
+company email and choose **Invite by email**. They appear on the roster as
+**invited** and become a collaborator automatically the first time they sign
+in, whether that's opening the project's URL or running `canopy login`. Until
+then the invite grants nothing. You can withdraw a pending invite from the
+same card. Canopy doesn't send them a message, so let them know yourself.
+
+Only company addresses that can sign in to Canopy can be invited. Owners (and
+admins) can also remove people from the same card.
 
 ## Collaborators-only mode
 

package/dist/docs/platform-slack.md

@@ -3,6 +3,12 @@ title: Slack
 description: Give your project its own Slack bot — Canopy creates and manages the app, your code handles the events.
 ---
 
+> **A bot, or just a message?** If all your project needs is to post to a
+> channel or DM a colleague, skip this page: `canopy.notify.slack` does that
+> through the Canopy bot with nothing to set up. Read
+> [Notify](https://docs.canopy.website/sdk/notify). Come back here when people need to talk to your
+> bot, run slash commands, or see your project's own name and icon.
+
 Your project can have its own Slack app: its own name and bot, in whatever
 workspace you choose. Canopy creates the app, keeps its settings in sync,
 holds every credential, and routes Slack's traffic to your backend. Your

package/dist/docs/sdk-notify.md

@@ -0,0 +1,140 @@
+---
+title: Notify
+description: Post a Slack message from your project through the Canopy bot — to your linked channels or a colleague's DMs — with nothing to set up.
+---
+
+`canopy.notify` tells people things on your project's behalf. The Canopy bot,
+the one that already DMs you about reports and deploys, delivers the message
+and says which project sent it. There is no Slack app to create, no token, no
+install: it works the moment your project has something to say.
+
+Two rules are enforced by the platform, not by your code:
+
+- **You reach people your project has a relationship with.** Channels are the
+  ones a project member linked with `/canopy link`; people are Canopy users,
+  named by the email they sign in with. Nothing else is addressable.
+- **A daily quota per project**, 200 deliveries by default. Each person and
+  each channel a message goes to counts as one.
+
+## notify.slack(options)
+
+Resolves once the platform has queued the message:
+
+```ts
+// Every channel linked to the project.
+await canopy.notify.slack({ text: "Export finished: *1,204* rows." });
+
+// A colleague, and nobody else.
+await canopy.notify.slack({
+  to: "someone@monks.com",
+  text: "Your approval is needed on <https://…|request #42>.",
+});
+
+// People and the linked channels together.
+await canopy.notify.slack({ to: ["a@monks.com", "b@monks.com"], channels: true, text: "…" });
+```
+
+**`NotifySlackOptions`:**
+
+- `text` — required, up to 2000 characters of Slack mrkdwn. Bold, links and
+  `<@U…>` mentions work.
+- `to` — optional. One email or an array of up to 20, each the address a
+  Canopy user signs in with. Leave it out to post to the linked channels
+  instead.
+- `channels` — optional. With `to`, also post to the linked channels. Without
+  `to` it is always on.
+
+**Returns** `{ queued }`, the number of deliveries queued: people plus
+channels. Delivery happens right after, with retries if Slack is slow; the
+outcome shows on the project's Usage tab.
+
+## What the message looks like
+
+Every message opens with a line the platform writes: your project's name,
+linked to its dashboard page, and "sent by this project via Canopy". Your
+text follows as a new top-level message. Nothing threads onto earlier
+messages, and there are no buttons or blocks: this is a notification, not a
+conversation.
+
+If someone replies under it, the Canopy assistant answers that the message
+came from your project and that replies don't reach it. If you want replies
+to reach your code, you want [a bot of your own](https://docs.canopy.website/platform/slack).
+
+## Who receives it
+
+Channels get every message. People are protected the same way platform
+notifications protect them: a colleague who muted your project hears
+nothing, and anyone can turn off "Messages from projects" in their
+notification settings. Someone whose email has no Slack account is skipped.
+None of this is reported back to your code, so `queued` counts what was
+sent, not what arrived.
+
+An email that is not a Canopy user is refused outright, so you notice the
+typo. Everyone at Monks becomes a Canopy user by opening the dashboard once.
+
+## Linking a channel
+
+Type `/canopy link <your-project-slug>` in the channel, then invite `@Canopy`
+to it. The channel now receives the project's messages, and its activity
+too: reports, project events, deploys. Linked channels are listed under the
+project's **Services → Slack**, where any member can unlink one.
+
+Until a channel is linked, a send without `to` fails with a 404 rather than
+disappearing silently.
+
+## Sending from the backend
+
+Like email, this is meant for code that runs with nobody signed in: a
+[scheduled](https://docs.canopy.website/platform/schedules) job, a worker route reacting to a webhook.
+It authenticates as the project itself. Browser code cannot call it.
+
+```ts
+export default {
+  async scheduled(event, env) {
+    const canopy = createCanopy({ fetch: env.CANOPY.fetch.bind(env.CANOPY) });
+    const stale = await staleRequests(env.DB);
+    if (stale.length === 0) return;
+
+    await canopy.notify.slack({
+      text: `${stale.length} approval request${stale.length === 1 ? "" : "s"} waiting longer than a week.`,
+    });
+  },
+};
+```
+
+## Seeing what was sent
+
+The project's **Usage** tab shows today's count against the quota and the
+recent sends: when, to whom, the first line, and whether it was delivered.
+Only that first line is kept.
+
+## When it fails
+
+Every failure is a `CanopyError` with a status you can branch on:
+
+- **400** — the text is empty or too long, `to` has more than 20 entries, or
+  an address is not a Canopy user (`unknown_recipient`, naming it).
+- **404** — no `to` and no linked channel (`no_linked_channel`).
+- **429** — the project used its daily quota, or the platform-wide ceiling is
+  reached. Both reset at UTC midnight.
+- **501** — this Canopy site has no Canopy bot.
+
+```ts
+import { CanopyError } from "@mediamonks/canopy";
+
+try {
+  await canopy.notify.slack({ text });
+} catch (err) {
+  if (err instanceof CanopyError && err.status === 404) {
+    // Nobody has linked a channel yet — tell a member to run /canopy link.
+  }
+}
+```
+
+## What this is not
+
+This is not a bot. It cannot listen, answer, show buttons, run slash
+commands, post in a client's workspace or carry your project's name and
+icon. The moment you want any of that, give the project [its own Slack
+app](https://docs.canopy.website/platform/slack): a few minutes of setup, and `canopy.slack` does the
+rest.

package/dist/docs/sdk-realtime.md

@@ -0,0 +1,149 @@
+---
+title: Realtime
+description: Live updates between the people using your app — subscribe to a topic, publish to it, no backend needed.
+---
+
+`canopy.realtime` sends small messages to everyone who has your app open,
+the moment something happens. A teammate adds a card and everyone's board
+refreshes; someone starts editing and the others see a "being edited" badge.
+It works from the browser alone, with nothing to set up.
+
+## Messages are hints, not a log
+
+Nothing is stored. A message reaches the pages that are connected when it's
+sent, and nobody else. A laptop that went to sleep, a tab that was in the
+background, a page that reconnected: each of them missed whatever was sent
+meanwhile.
+
+So build it like this: keep your data in [`canopy.db`](https://docs.canopy.website/sdk/database),
+send a message to say _what changed_, and reload from the database whenever
+the connection opens.
+
+```ts
+const off = canopy.realtime.subscribe(
+  "board",
+  (message) => refreshCard(message.data.cardId),
+  { onOpen: () => reloadBoard() }, // first connect and every reconnect
+);
+
+// …somewhere else, after saving the change:
+await canopy.db.collection("cards").update(card.id, { column: "done" });
+await canopy.realtime.publish("board", { cardId: card.id });
+
+off(); // stop listening
+```
+
+## realtime.subscribe(topic, onMessage, options?)
+
+Starts listening to `topic` and returns a function that stops. Every
+subscription on a page shares one connection, so subscribe to as many topics
+as you need (up to 20 per page).
+
+- `onMessage(message)` runs for each message on the topic, including the ones
+  this page published itself. Ignore your own by comparing `message.id` with
+  what `publish` returned.
+- `onOpen()` runs whenever the connection opens: the first time, and after
+  every reconnect. Reload what you show from the database here.
+- `onError(error)` reports connection problems. `error.code` says which. The
+  SDK keeps retrying on its own unless retrying can't help (see
+  [When it's off](#when-its-off)).
+
+A message looks like this:
+
+```ts
+{
+  id: "0muz…",            // the id publish() returned to the sender
+  topic: "board",
+  data: { cardId: "c-7" }, // whatever was published
+  from: { kind: "monk", email: "ada@monks.com" },
+  ts: "2026-10-08T12:00:00.000Z",
+}
+```
+
+`from` is filled in by Canopy, never by the sender, so you can trust it:
+`monk` (with their sign-in email), `external` for a visitor who came in with
+the [client password](https://docs.canopy.website/platform/client-access), or `worker` for your
+project's backend. Client visitors never see a monk's email; for them the
+sender is just `monk`.
+
+## realtime.publish(topic, data)
+
+Sends `data` (any JSON value, up to 4 KB) to everyone subscribed to `topic`,
+and resolves with `{ id }`. Send an id and let pages load the rest from the
+database; a message over 4 KB is refused with `message_too_large`.
+
+Topic names are 1 to 64 letters, digits, `-`, `_` or `.`. They belong to your
+project only: another project's `board` is a different topic, and so is your
+own staging site's.
+
+## Topics only your backend can publish to
+
+Topics that start with `worker:` take messages from your project's backend
+only. Pages can listen to them, but anything else that tries to publish gets
+`topic_worker_only`: a page, the dashboard, or a personal token like the one
+`canopy dev` uses. Use them for news that has to come from the server: a
+job finished, a payment cleared, an import is done.
+
+```ts
+// In your worker (worker/index.ts):
+const canopy = createCanopy({ fetch: c.env.CANOPY.fetch.bind(c.env.CANOPY) });
+await canopy.realtime.publish("worker:imports", { importId, status: "done" });
+```
+
+Messages from the backend arrive with `from.kind: "worker"`, also when the
+backend is handling a signed-in visitor's request. A scheduled job can
+publish too.
+
+## Limits
+
+- **4 KB** of data per message.
+- **20 topics** per page.
+- **100 open connections** per project at a time, and **10 per person**. One
+  more gets `too_many_subscribers` through `onError` and keeps retrying until
+  a connection closes.
+- **A daily quota** per project: 100,000 messages by default, and a share of
+  data delivered (big messages to many people use it up faster). When either
+  is used up, `publish` is refused with `realtime_quota_exceeded` until
+  midnight UTC; subscriptions stay open. The Usage tab shows today's count. A
+  Canopy admin can raise the message quota if you need more.
+- If many projects are busy at once, the whole site can reach its own daily
+  limit. Publishes then fail with `realtime_platform_limit`; that one isn't
+  about your project.
+
+For cursors or presence, throttle updates to at most a few per second per
+person. That's smooth to look at and keeps you well inside the quota.
+
+## Background tabs
+
+A tab that has been in the background for two minutes stops receiving
+messages and lets its connection go. When you switch back, it reconnects
+right away and `onOpen` runs, so the page catches up from the database. A
+quick switch away and back keeps the connection.
+
+Every connection also renews itself about every quarter of an hour, and
+whenever access to the project changes (the client password, collaborators
+only, someone removed). Each renewal runs `onOpen` again, which is what
+keeps the reload-on-open pattern correct.
+
+## When it's off
+
+Realtime is a per-project setting that Canopy admins manage. If it's off for
+your project, `subscribe` reports `realtime_not_enabled` through `onError`
+once and `publish` is refused with the same code. Ask a Canopy admin to turn
+it on. The Usage tab shows whether it's on.
+
+Some Canopy sites don't run realtime at all; there the error is
+`not_supported_on_target`. In both cases the SDK doesn't keep retrying.
+
+## Topics are not secrets
+
+Anyone who can open your app can subscribe to any of its topics. Don't put
+anything in a message that the people using the app shouldn't see, and don't
+treat a hard-to-guess topic name as a password.
+
+## In local development
+
+`canopy dev` connects to the real topics of your live project, so a local tab
+and the deployed site see each other's messages. `canopy dev --local` keeps
+everything on your laptop: open two tabs and they talk to each other, with no
+quota and no `worker:` rule (like the local database, nothing is guarded).

package/dist/docs/sdk-slack.md

@@ -3,6 +3,9 @@ title: Slack
 description: Handle your bot's events and slash commands in your worker, and post to Slack as the bot — no tokens in project code.
 ---
 
+> Only want to post a message? [`canopy.notify.slack`](https://docs.canopy.website/sdk/notify) does it
+> through the Canopy bot, no app needed. This page is for a bot of your own.
+
 Once your project has a Slack app ([set up on the Services
 tab](https://docs.canopy.website/platform/slack)), the integration is two halves: inbound events arrive
 at a `slack()` export in your worker, and outbound calls go through

package/dist/docs/sdk.md

@@ -1,11 +1,11 @@
 ---
 title: Using the SDK
-description: One typed client for auth, data, files, AI, email, and services — no keys, no connection strings, the platform authenticates for you.
+description: One typed client for auth, data, files, AI, email, notify, realtime, and services — no keys, no connection strings, the platform authenticates for you.
 ---
 
 `@mediamonks/canopy` is a thin, typed client over the platform's project API.
-One `createCanopy()` call gives you seven modules — `auth`, `db`, `blob`, `ai`,
-`email`, `google`, and `services` — and that is the entire surface. There are no API keys,
+One `createCanopy()` call gives you its modules — `auth`, `db`, `blob`, `ai`,
+`email`, `notify`, `realtime`, `google`, `slack`, and `services` — and that is the entire surface. There are no API keys,
 connection strings, or environment variables to manage: every call rides the
 session the platform already established before your code ran.
 
@@ -35,7 +35,8 @@ import { createCanopy } from "/_api/data/v1/sdk.js";
 import { createCanopy } from "@mediamonks/canopy";
 
 const canopy = createCanopy();
-// canopy.auth, canopy.db, canopy.blob, canopy.ai, canopy.email, canopy.google, canopy.services
+// canopy.auth, canopy.db, canopy.blob, canopy.ai, canopy.email, canopy.notify,
+// canopy.realtime, canopy.google, canopy.slack, canopy.services
 ```
 
 | Option    | Type           | Default        | What it does                                                                                                          |

package/dist/docs/static-serving.md

@@ -77,5 +77,24 @@ belong in [file storage](https://docs.canopy.website/sdk/files) instead of the b
   reachable, deploy it, or put it in [file storage](https://docs.canopy.website/sdk/files) and hand out a
   signed link.
 
+## Moving a project to a new address
+
+When a project lives somewhere else now — it was rebuilt under another name,
+or it graduated to its own domain — you can point the old address at the new
+one. On the project's **Settings** page, the **Move project** card takes an
+`https://` URL. From then on every request to the old address, including deep
+links with their path and query, lands on the new URL.
+
+A few things to know:
+
+- **Visitors still sign in on the old address first.** The redirect happens
+  behind the same sign-in wall as everything else, so a colleague signs in once
+  and is sent on; a client-password visitor types the old password once.
+- **The old project goes quiet.** Deploys are refused, the backend and
+  schedules stop. Its database and files stay put, and `canopy db pull` still
+  works, so you can take the data with you after the move.
+- **It's reversible.** Undo the move on the same card and the last deployed
+  build is served again right away.
+
 Porting an app that assumed a server? [Porting a Next.js app](https://docs.canopy.website/guides/porting-nextjs)
 walks through the restructure.

package/dist/{docs-CuS9nIXm.mjs → docs-ZQnhFSKT.mjs}

@@ -1,7 +1,7 @@
-import { t as version } from "./package-CsmBH_fN.mjs";
+import { t as version } from "./package-DzU_2IJi.mjs";
 import { n as siteConfig } from "./site-DM2J10CB.mjs";
 import { i as latestKnownVersion, r as compareSemver } from "./version-check-CcsA1QjI.mjs";
-import { r as reportErrors } from "./ui-DR-siu2S.mjs";
+import { r as reportErrors } from "./ui-CeupNHNa.mjs";
 import { defineCommand } from "citty";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";

package/dist/{egress-Cn-P46O3.mjs → egress-Cn9zDfDT.mjs}

@@ -1,5 +1,5 @@
 import { a as projectDirArgs, c as resolveProject } from "./site-DM2J10CB.mjs";
-import { a as unwrap, d as withContext, i as requireTty, l as apiRequest, r as reportErrors, t as formatDateTime } from "./ui-DR-siu2S.mjs";
+import { a as unwrap, d as withContext, i as requireTty, l as apiRequest, r as reportErrors, t as formatDateTime } from "./ui-CeupNHNa.mjs";
 import { defineCommand } from "citty";
 import * as p from "@clack/prompts";
 //#region src/egress.ts