npm - @pylonsync/create-pylon - Versions diffs - 0.3.267 → 0.3.269 - Mend

@pylonsync/create-pylon 0.3.267 → 0.3.269

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (90) hide show

package/bin/create-pylon.js +18 -10
package/package.json +1 -1
package/templates/b2b/AGENTS.md +61 -0
package/templates/b2b/README.md +62 -0
package/templates/b2b/app/auth-form.tsx +142 -0
package/templates/b2b/app/dashboard/dashboard-client.tsx +192 -0
package/templates/b2b/app/dashboard/page.tsx +63 -0
package/templates/b2b/app/error.tsx +43 -0
package/templates/b2b/app/globals.css +139 -0
package/templates/b2b/app/layout.tsx +71 -0
package/templates/b2b/app/login/page.tsx +47 -0
package/templates/b2b/app/not-found.tsx +29 -0
package/templates/b2b/app/page.tsx +114 -0
package/templates/b2b/app/robots.ts +12 -0
package/templates/b2b/app/signup/page.tsx +44 -0
package/templates/b2b/app/sitemap.ts +27 -0
package/templates/b2b/app.ts +179 -0
package/templates/b2b/components/ui/button.tsx +56 -0
package/templates/b2b/components/ui/card.tsx +90 -0
package/templates/b2b/components.json +20 -0
package/templates/b2b/functions/_keep.ts +13 -0
package/templates/b2b/gitignore +10 -0
package/templates/b2b/lib/utils.ts +10 -0
package/templates/b2b/package.json +33 -0
package/templates/b2b/tsconfig.json +18 -0
package/templates/barebones/AGENTS.md +61 -0
package/templates/barebones/README.md +45 -0
package/templates/barebones/app/error.tsx +43 -0
package/templates/barebones/app/globals.css +139 -0
package/templates/barebones/app/items-client.tsx +96 -0
package/templates/barebones/app/layout.tsx +27 -0
package/templates/barebones/app/not-found.tsx +29 -0
package/templates/barebones/app/page.tsx +28 -0
package/templates/barebones/app/robots.ts +12 -0
package/templates/barebones/app/sitemap.ts +27 -0
package/templates/barebones/app.ts +55 -0
package/templates/barebones/components/ui/button.tsx +56 -0
package/templates/barebones/components/ui/card.tsx +90 -0
package/templates/barebones/components.json +20 -0
package/templates/barebones/functions/_keep.ts +13 -0
package/templates/barebones/gitignore +10 -0
package/templates/barebones/lib/utils.ts +10 -0
package/templates/barebones/package.json +33 -0
package/templates/barebones/tsconfig.json +18 -0
package/templates/chat/AGENTS.md +61 -0
package/templates/chat/README.md +51 -0
package/templates/chat/app/chat-client.tsx +113 -0
package/templates/chat/app/error.tsx +43 -0
package/templates/chat/app/globals.css +139 -0
package/templates/chat/app/layout.tsx +25 -0
package/templates/chat/app/not-found.tsx +29 -0
package/templates/chat/app/page.tsx +26 -0
package/templates/chat/app/robots.ts +12 -0
package/templates/chat/app/sitemap.ts +27 -0
package/templates/chat/app.ts +59 -0
package/templates/chat/components/ui/button.tsx +56 -0
package/templates/chat/components/ui/card.tsx +90 -0
package/templates/chat/components.json +20 -0
package/templates/chat/functions/_keep.ts +13 -0
package/templates/chat/gitignore +10 -0
package/templates/chat/lib/utils.ts +10 -0
package/templates/chat/package.json +33 -0
package/templates/chat/tsconfig.json +18 -0
package/templates/consumer/AGENTS.md +61 -0
package/templates/consumer/README.md +52 -0
package/templates/consumer/app/error.tsx +43 -0
package/templates/consumer/app/feed-client.tsx +154 -0
package/templates/consumer/app/globals.css +139 -0
package/templates/consumer/app/layout.tsx +27 -0
package/templates/consumer/app/not-found.tsx +29 -0
package/templates/consumer/app/page.tsx +27 -0
package/templates/consumer/app/robots.ts +12 -0
package/templates/consumer/app/sitemap.ts +27 -0
package/templates/consumer/app.ts +89 -0
package/templates/consumer/components/ui/button.tsx +56 -0
package/templates/consumer/components/ui/card.tsx +90 -0
package/templates/consumer/components.json +20 -0
package/templates/consumer/functions/_keep.ts +13 -0
package/templates/consumer/gitignore +10 -0
package/templates/consumer/lib/utils.ts +10 -0
package/templates/consumer/package.json +33 -0
package/templates/consumer/tsconfig.json +18 -0
package/templates/ssr/README.md +43 -28
package/templates/ssr/app/dashboard/dashboard-client.tsx +154 -78
package/templates/ssr/app/dashboard/page.tsx +16 -60
package/templates/ssr/app/layout.tsx +46 -39
package/templates/ssr/app/login/page.tsx +1 -1
package/templates/ssr/app/page.tsx +182 -84
package/templates/ssr/app/signup/page.tsx +1 -1
package/templates/ssr/app.ts +134 -46

package/templates/barebones/app/layout.tsx ADDED Viewed

@@ -0,0 +1,27 @@
+import React from "react";
+// A layout wraps every page. This one is a header and a centered column —
+// the page renders server-side first (shell + copy in the HTML), then
+// hydrates into the live list.
+interface LayoutProps {
+  children: React.ReactNode;
+}
+export default function RootLayout({ children }: LayoutProps) {
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <title>__APP_NAME__</title>
+        {/* Tailwind is compiled by Pylon from app/globals.css and the
+            stylesheet link is injected here automatically. */}
+      </head>
+      <body className="min-h-screen bg-background text-foreground antialiased">
+        <main className="mx-auto flex min-h-screen max-w-lg flex-col px-4 py-12">
+          {children}
+        </main>
+      </body>
+    </html>
+  );
+}

package/templates/barebones/app/not-found.tsx ADDED Viewed

@@ -0,0 +1,29 @@
+import React from "react";
+import { Link, useRouter, type NotFoundProps } from "@pylonsync/react";
+import { Button } from "@/components/ui/button";
+// `app/not-found.tsx` → rendered at HTTP 404 for any unmatched URL (and when
+// a page calls `response.notFound()`). It's HYDRATED, so it's interactive:
+// the buttons below use the client router. Not-found boundaries receive the
+// standard page props (and, matching Next, no `reset`).
+export default function NotFound(_props: NotFoundProps) {
+  const router = useRouter();
+  return (
+    <div className="space-y-6">
+      <section>
+        <h1 className="text-2xl font-semibold tracking-tight">404</h1>
+        <p className="mt-2 text-muted-foreground">
+          We couldn&apos;t find that page.
+        </p>
+      </section>
+      <div className="flex items-center gap-3">
+        <Button onClick={() => router.back()} variant="outline">
+          ← Go back
+        </Button>
+        <Button asChild>
+          <Link href="/">Home</Link>
+        </Button>
+      </div>
+    </div>
+  );
+}

package/templates/barebones/app/page.tsx ADDED Viewed

@@ -0,0 +1,28 @@
+import React from "react";
+import { type Metadata } from "@pylonsync/react";
+import { ItemList } from "./items-client";
+export const metadata: Metadata = {
+  title: "__APP_NAME__ — a minimal Pylon app",
+  description:
+    "One entity, a live list, and an optimistic create — server-rendered over one Pylon backend, one binary, one port.",
+};
+// `app/page.tsx` → `/`. The heading is server-rendered; the list is a client
+// island (`<ItemList>`) that mints a guest session and runs the live query +
+// optimistic create in the browser. This is the whole app — edit
+// `app/items-client.tsx` for the UI or `app.ts` for the data model.
+export default function IndexPage() {
+  return (
+    <div className="flex flex-1 flex-col">
+      <header className="mb-8">
+        <h1 className="text-3xl font-semibold tracking-tight">Items</h1>
+        <p className="mt-1 text-sm text-muted-foreground">
+          One entity, a live list, optimistic writes. The smallest working
+          Pylon app — grow it from here.
+        </p>
+      </header>
+      <ItemList />
+    </div>
+  );
+}

package/templates/barebones/app/robots.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import type { Robots } from "@pylonsync/react";
+// app/robots.ts → served at /robots.txt. The default export may also be async.
+const SITE = process.env.SITE_URL ?? "http://localhost:4321";
+export default function robots(): Robots {
+  return {
+    // Keep the authenticated app and the API out of the index.
+    rules: { userAgent: "*", allow: "/", disallow: ["/dashboard", "/api/"] },
+    sitemap: `${SITE}/sitemap.xml`,
+  };
+}

package/templates/barebones/app/sitemap.ts ADDED Viewed

@@ -0,0 +1,27 @@
+import type { Sitemap } from "@pylonsync/react";
+// app/sitemap.ts → served at /sitemap.xml. The default export can be async, so
+// it can enumerate dynamic pages from your database. Point SITE_URL at your
+// domain in production.
+const SITE = process.env.SITE_URL ?? "http://localhost:4321";
+export default async function sitemap(): Promise<Sitemap> {
+  // Only public pages belong here — /dashboard is private (and noindex), so
+  // it's intentionally left out.
+  const staticRoutes: Sitemap = [
+    { url: `${SITE}/`, changeFrequency: "weekly", priority: 1 },
+    { url: `${SITE}/login`, changeFrequency: "yearly", priority: 0.3 },
+    { url: `${SITE}/signup`, changeFrequency: "yearly", priority: 0.5 },
+  ];
+  // The export is async, so you can enumerate dynamic pages from a DB read:
+  //
+  //   const posts = await fetchPublishedPosts();
+  //   const postRoutes: Sitemap = posts.map((p) => ({
+  //     url: `${SITE}/blog/${p.slug}`,
+  //     lastModified: p.updatedAt,
+  //   }));
+  //   return [...staticRoutes, ...postRoutes];
+  return staticRoutes;
+}

package/templates/barebones/app.ts ADDED Viewed

@@ -0,0 +1,55 @@
+import {
+  entity,
+  field,
+  policy,
+  auth,
+  buildManifest,
+  discoverAppRoutes,
+} from "@pylonsync/sdk";
+// The smallest useful Pylon app: one entity, owned by its creator, with a
+// live list and an optimistic create. `userId: field.owner()` stamps the
+// signed-in (here: guest) user's id server-side and rejects any forged
+// value, so the UI can do a plain `db.insert("Item", { text })` and the row
+// stays unspoofably yours.
+const Item = entity(
+  "Item",
+  {
+    userId: field.string().owner(),
+    text: field.string(),
+    createdAt: field.datetime().defaultNow(),
+  },
+  { indexes: [{ name: "by_user", fields: ["userId"], unique: false }] },
+);
+// Items are private to their owner. An entity with NO policy is denied to
+// clients by default, so this allow-list is what makes the live query +
+// optimistic writes work — and only for your own rows.
+const itemPolicy = policy({
+  name: "item_access",
+  entity: "Item",
+  allowRead: "auth.userId == data.userId",
+  allowInsert: "auth.userId != null",
+  allowUpdate: "auth.userId == data.userId",
+  allowDelete: "auth.userId == data.userId",
+});
+// The manifest is your whole app: data, policies, and the file-based routes
+// under `app/`. `pylon dev` serves the SSR frontend and the API from one
+// port. Guest sessions (via `<EnsureGuest>` on the page) mean every visitor
+// implicitly becomes their own user — no login wall. Add fields to `Item`, or
+// a second `entity()`, and the typed client + REST/realtime API follow.
+const manifest = buildManifest({
+  name: "__APP_NAME__",
+  version: "0.1.0",
+  entities: [Item],
+  queries: [],
+  actions: [],
+  policies: [itemPolicy],
+  auth: auth(),
+  routes: await discoverAppRoutes(),
+});
+console.log(JSON.stringify(manifest, null, 2));
+export default manifest;

package/templates/barebones/components/ui/button.tsx ADDED Viewed

@@ -0,0 +1,56 @@
+import * as React from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { cva, type VariantProps } from "class-variance-authority";
+import { cn } from "@/lib/utils";
+const buttonVariants = cva(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive:
+          "bg-destructive text-white hover:bg-destructive/90",
+        outline:
+          "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+        secondary:
+          "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default: "h-9 px-4 py-2",
+        sm: "h-8 rounded-md px-3 text-xs",
+        lg: "h-10 rounded-md px-8",
+        icon: "h-9 w-9",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  },
+);
+export interface ButtonProps
+  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
+    VariantProps<typeof buttonVariants> {
+  asChild?: boolean;
+}
+const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
+  ({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Comp = asChild ? Slot : "button";
+    return (
+      <Comp
+        className={cn(buttonVariants({ variant, size, className }))}
+        ref={ref}
+        {...props}
+      />
+    );
+  },
+);
+Button.displayName = "Button";
+export { Button, buttonVariants };

package/templates/barebones/components/ui/card.tsx ADDED Viewed

@@ -0,0 +1,90 @@
+import * as React from "react";
+import { cn } from "@/lib/utils";
+function Card({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) {
+  return (
+    <div
+      data-slot="card"
+      className={cn(
+        "rounded-xl border bg-card text-card-foreground shadow-sm",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+function CardHeader({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) {
+  return (
+    <div
+      data-slot="card-header"
+      className={cn("flex flex-col space-y-1.5 p-6", className)}
+      {...props}
+    />
+  );
+}
+function CardTitle({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) {
+  return (
+    <div
+      data-slot="card-title"
+      className={cn("font-semibold leading-none tracking-tight", className)}
+      {...props}
+    />
+  );
+}
+function CardDescription({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) {
+  return (
+    <div
+      data-slot="card-description"
+      className={cn("text-sm text-muted-foreground", className)}
+      {...props}
+    />
+  );
+}
+function CardContent({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) {
+  return (
+    <div
+      data-slot="card-content"
+      className={cn("p-6 pt-0", className)}
+      {...props}
+    />
+  );
+}
+function CardFooter({
+  className,
+  ...props
+}: React.HTMLAttributes<HTMLDivElement>) {
+  return (
+    <div
+      data-slot="card-footer"
+      className={cn("flex items-center p-6 pt-0", className)}
+      {...props}
+    />
+  );
+}
+export {
+  Card,
+  CardHeader,
+  CardFooter,
+  CardTitle,
+  CardDescription,
+  CardContent,
+};

package/templates/barebones/components.json ADDED Viewed

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "app/globals.css",
+    "baseColor": "zinc",
+    "cssVariables": true
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "iconLibrary": "lucide"
+}

package/templates/barebones/functions/_keep.ts ADDED Viewed

@@ -0,0 +1,13 @@
+// Server functions go here. Each file in this directory that exports a
+// query() or action() becomes a typed RPC endpoint, callable from your
+// pages and client with full type inference. Delete this placeholder when
+// you add your first one.
+//
+// Example (functions/notes.ts):
+//
+//   import { query } from "@pylonsync/functions";
+//
+//   export const listNotes = query(async (ctx) => {
+//     return ctx.db.list("Note");
+//   });
+export {};

package/templates/barebones/gitignore ADDED Viewed

@@ -0,0 +1,10 @@
+node_modules/
+.pylon/
+pylon.manifest.json
+pylon.client.ts
+web/dist/
+*.db
+*.db-*
+.env
+.env.local
+.DS_Store

package/templates/barebones/lib/utils.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+// `cn` — the shadcn class merger. clsx resolves conditional/array class
+// inputs; tailwind-merge then dedupes conflicting Tailwind utilities so
+// the last one wins (e.g. `cn("px-2", "px-4")` → "px-4"). Every shadcn
+// component routes its className through this.
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/templates/barebones/package.json ADDED Viewed

@@ -0,0 +1,33 @@
+{
+  "name": "__APP_NAME_KEBAB__",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "pylon dev",
+    "deploy": "pylon deploy",
+    "check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@pylonsync/react": "^__PYLON_VERSION__",
+    "@pylonsync/sdk": "^__PYLON_VERSION__",
+    "@pylonsync/functions": "^__PYLON_VERSION__",
+    "@pylonsync/client": "^__PYLON_VERSION__",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tailwindcss": "^4.3.0",
+    "@tailwindcss/cli": "^4.3.0",
+    "tw-animate-css": "^1.2.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^2.5.0",
+    "lucide-react": "^0.460.0",
+    "@radix-ui/react-slot": "^1.1.0"
+  },
+  "devDependencies": {
+    "@pylonsync/cli": "^__PYLON_VERSION__",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "typescript": "^5.6.0"
+  }
+}

package/templates/barebones/tsconfig.json ADDED Viewed

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "lib": ["ES2022", "DOM"],
+    "types": ["react", "react-dom"],
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["app.ts", "app/**/*", "components/**/*", "lib/**/*"]
+}

package/templates/chat/AGENTS.md ADDED Viewed

@@ -0,0 +1,61 @@
+# AGENTS.md — working in a Pylon project
+Operating rules for a coding agent in this Pylon app. Pylon is a Rails-like framework for realtime apps: you declare entities, policies, and server functions in TypeScript, and a single Rust binary (`pylon`) serves the API, auth, sync, WebSocket, SSE, and native React 19 SSR — one process, one port. The full API reference is at **/llms-full.txt** (served at `/llms-full.txt`; in the repo at `apps/web/public/llms-full.txt`). Read it before guessing an API name.
+## Directory conventions
+**Unified SSR app:**
+- `app.ts` — data model + manifest (`entity()` + `field.*`, queries/actions/policies, `routes: await discoverAppRoutes()`). Ends with `console.log(JSON.stringify(manifest))`.
+- `app/` — file-based SSR routes. `app/page.tsx` → `/`, `app/about/page.tsx` → `/about`, `app/blog/[slug]/page.tsx` → `/blog/:slug`. `app/layout.tsx` is the shell; `app/error.tsx` / `app/not-found.tsx` are boundaries.
+- `app/globals.css` — Tailwind v4 entrypoint (auto-compiled and injected).
+- `functions/` — server functions, one per file, `default`-exported.
+- `.pylon/` — local dev state (sqlite, jobs, sessions, uploads). Created by `pylon dev`. Do not commit.
+**Monorepo app:** backend is `apps/api/` (entry `apps/api/schema.ts`, handlers in `apps/api/functions/`); frontend in `apps/web/`. `pylon.manifest.json` / `pylon.client.ts` are generated — do not hand-edit.
+## The core authoring loop
+1. **Define an entity** — `entity("Thing", { name: field.string(), done: field.boolean().default(false) })`. Modifiers: `.optional()`, `.unique()`, `.readonly()` (settable on insert, rejected on client update — use for `authorId`/`orgId`), `.serverOnly()` (never in HTTP responses), `.encrypted()` (AEAD at rest, needs `PYLON_ENCRYPTION_KEY`), `.crdt("text")` (collaborative).
+2. **Write a policy** — `policy({ entity: "Thing", allowRead, allowInsert, allowUpdate, allowDelete })` with CEL-like expressions over `auth.*` / `data.*` (e.g. `"auth.userId == data.authorId"`). **Omitted actions DENY by default.** Wide-open dev policies (`allow*: "true"`) are flagged by `pylon lint` — tighten before shipping.
+3. **Author a function** in `functions/<name>.ts` — `query` (read-only), `mutation` (transactional read+write), or `action` (external I/O, no direct `ctx.db`). Import `{ query, mutation, action, v }` from `@pylonsync/functions`. `auth` defaults to `"user"` (secure-by-default); set `"public"` explicitly for unauthenticated access. Use `ctx.db.*`, `ctx.auth.userId`, `ctx.error(code, msg)`.
+4. **Read it on the client** — `db.useQuery("Thing")` (live, re-renders on any write) or `db.useQueryOne("Thing", id)`. Call functions with `db.fn(name, args)` / `callFn`. On SSR pages, read via `use(serverData.list("Thing"))` inside `<Suspense>`.
+## Key gotchas
+- **Policies deny by default; server functions BYPASS them.** Direct client CRUD (`/api/entities/*`) and sync are policy-checked. Functions run with full DB access — enforce trust with `ctx.auth` checks inside the handler, not policies.
+- **Type page props from the SDK, don't hand-roll them.** `import type { PageProps, Metadata } from "@pylonsync/react"`. Every page/layout gets `{ url, params, searchParams, auth, response, serverData }`; `PageProps<{ slug: string }>` types a `[slug]` route's params. Request headers/cookies are intentionally NOT on `PageProps` — they're server-only and stripped from hydration, so reading them in the render would mismatch.
+- **Anonymous output caching is opt-in + earned.** `export const revalidate = 60` (seconds) on a page makes it CDN-cacheable (`public, s-maxage=60`) — but ONLY if the render is auth-INDEPENDENT: it must NOT read `props.auth` (reading it at all opts out, even for anonymous), set no cookie, and the app must not run strict per-caller policies (`PYLON_STRICT_FN_POLICIES`). `export const dynamic = "force-static"` caches until the next deploy; `"force-dynamic"` never caches. Fail-closed: without the opt-in (or if any condition fails) the page is `no-cache`. A page that reads `auth` or sets a cookie is never shared. The SAME earned render is also kept in an **origin disk cache** (`.pylon/.cache/ssr`): a cookie-less GET with no query string is served straight off disk for the TTL — skipping the render entirely — then re-rendered live when stale. The disk cache is namespaced per deploy (wiped on each new build) and OFF in `pylon dev` (so an edit is never masked by a stale entry); invalidation is by the `revalidate` TTL or the next deploy.
+- **No-JS forms use `route.ts` + `<Form>`.** Drop `app/.../route.ts` exporting `export const POST: RouteHandler = async ({ form, db, response, auth }) => { await db.insert("X", {...}); response.redirect("/x?ok=1"); }` (303 POST-redirect-GET by default). Render `<Form action="/x">` (from @pylonsync/react) with plain `<input name=...>` — works with JS off (native POST→handler→redirect) and is enhanced to no-reload when JS is on. The handler's `db` is read+write (mutation trust model — gate on `auth`); CSRF is automatic (Origin gate + SameSite=Lax). Multipart/file uploads aren't supported yet — use urlencoded forms + `/api/files`.
+- **`loading.tsx` streams a skeleton while the page's data resolves.** Drop `app/.../loading.tsx` (default export, page props) and the nearest one becomes a route-level Suspense fallback: Pylon flushes the shell + skeleton immediately, then reveals the real page when its top-level `use(serverData…)` resolves (no blank page). It only shows when the PAGE suspends — a page that wraps its own `<Suspense>` around a child (like `/dashboard` in this template) handles that itself. The skeleton is SERVER-ONLY: don't read `serverData` in it. A page with no `loading.tsx` is buffered (unchanged).
+- **`export const streaming = true` streams a page's OWN inner `<Suspense>` boundaries.** Without it (and without a `loading.tsx`), a page is BUFFERED — the whole document, including suspended children, resolves before the first byte. Opt in and the shell + each inner `<Suspense>` fallback flush immediately, then each boundary's real content streams in as its data resolves (multi-boundary progressive streaming). It's opt-in because it changes the response timing contract: a streaming render commits its HTTP head BEFORE suspended subtrees finish, so (a) it's never CDN/disk cacheable — don't combine with `export const revalidate`; (b) `response.setStatus/setCookie/redirect/notFound` only take effect from the SYNCHRONOUS shell render — a call from inside a suspended subtree is dropped (the runtime logs a loud warning naming what was lost); (c) a `throw` from a deep `<Suspense>` child resolves via its nearest `error.tsx` at HTTP 200, not a 5xx. Hydration is clean for any number of boundaries (the data blob ships before hydration runs). Type the config with `import type { RouteSegmentConfig } from "@pylonsync/react"`.
+- **`error.tsx` / `not-found.tsx` boundaries are HYDRATED (interactive).** `app/.../error.tsx` catches a throw below it (HTTP 500) and receives `{ error: { message, digest }, reset }` (`import type { ErrorBoundaryProps }`) — `reset()` re-attempts the route; the stack NEVER reaches the client (dev overlay + logs only). `app/.../not-found.tsx` renders at 404 (also for `response.notFound()`) and gets the page props (`NotFoundProps`), no `reset`. Both run useState/onClick/hooks.
+- **Client navigation hooks live in @pylonsync/react.** `useRouter()` → `{ push, replace, back, forward, refresh, prefetch }`; `useSearchParams()` → reactive `URLSearchParams`; `usePathname()` → reactive pathname. The hooks are CLIENT-reactive — during SSR they return defaults (empty params / "/"); for server-side URL values read the `url` / `searchParams` page props.
+- **Dynamic + catch-all routes follow Next conventions.** `app/blog/[slug]/page.tsx` → `params.slug`. `app/docs/[...path]/page.tsx` is a catch-all (matches `/docs/a/b/c`; `params.path === "a/b/c"` — `.split("/")` for segments). `app/shop/[[...filters]]/page.tsx` is an optional catch-all (also matches the bare `/shop`, with `params.filters === ""`). A catch-all must be the last segment; static beats dynamic beats catch-all on overlap.
+- **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
+- **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready — status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
+- **`ctx.llm` and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db` — use `ctx.runQuery` / `ctx.runMutation`.
+- **It's `db.useQueryOne`, not `useOne`.** Validators and field types have aliases: `v.bool`/`v.boolean`, `v.float`/`v.number`.
+- **There is no `ctx.files` or `defineWorkflow`/`defineJob`.** Files go through `<FileUpload>` + `/api/files/*`; deferred execution is `ctx.scheduler.runAfter/runAt/cancel`.
+## Use the CLI — don't guess
+| Need | Command |
+|---|---|
+| Run the app (SSR + API, hot reload, one port `:4321`) | `pylon dev` (or `npm run dev`) |
+| Regenerate manifest + typed client | `pylon codegen` (Swift client: `pylon codegen client --target swift`) |
+| Validate / diff / push schema | `pylon schema check` \| `diff` \| `push` |
+| Migrations | `pylon migrate create <name>` \| `plan` \| `apply` |
+| Lint policies (PYL001–PYL004) | `pylon lint --strict` |
+| Tests | `pylon test` |
+| Adversarial security probe | `pylon test:security` |
+| Inspect cloud request logs (agent-safe) | `pylon logs --json --limit 50` |
+| Inspect data / entities | `pylon data entities` \| `pylon data list <Entity>` |
+| Call a function | `pylon fn <name> key=value` |
+| Health snapshot | `pylon status` |
+| Build for prod | `pylon build` |
+| Deploy (Pylon Cloud by default) | `pylon deploy` |
+| Look up an error code | `pylon explain <CODE>` |
+`--json` works on every command for machine-readable output. Prefer one-shot/agent-safe flags (`pylon logs --limit N`, not a blocking `--follow`).
+For full signatures, env vars, the complete CLI, and SSR/client/server-primitive details: **/llms-full.txt**.

package/templates/chat/README.md ADDED Viewed

@@ -0,0 +1,51 @@
+# __APP_NAME__
+A realtime chat room on [Pylon](https://pylonsync.com) — a live, shared message
+room served over one synced backend. One binary, one port. No Next.js, no
+separate API server, no realtime sidecar.
+## Develop
+```bash
+__RUN_DEV__
+```
+Open http://localhost:4321, then open a **second tab** — type in one and the
+message appears in the other instantly. Edit any file under `app/` and save —
+the page reloads.
+## Layout
+```
+app.ts              data model: the Message entity + room policy + auth
+app/page.tsx        "/" — the server-rendered page
+app/chat-client.tsx client island: guest session + live messages, optimistic send
+app/layout.tsx      full-height root layout
+app/globals.css     Tailwind entrypoint (compiled by Pylon)
+```
+## How it works
+No login wall: `app/chat-client.tsx` wraps the room in `<EnsureGuest>`, which
+mints a guest session so anyone can chat. The room is **public-read** (everyone
+sees every message — that's a chat room), and `authorId: field.owner()` stamps
+the sender server-side so a message can't be spoofed. `db.useQuery("Message")`
+is a **live subscription** — new messages render the instant they're sent, in
+any tab, with no polling and no extra code.
+## Grow it
+- **Multiple rooms:** add a `Room` entity and a `roomId` field on `Message`,
+  then filter `db.useQuery` by the selected room.
+- **Presence ("who's here"):** use a presence channel (`ctx.connections.*`) to
+  track connected users.
+- **Real accounts:** email/password is built in — swap `<EnsureGuest>` for
+  `<SignedIn>` / `<SignedOut>` from `@pylonsync/client`.
+## Deploy
+```bash
+pylon deploy
+```
+Docs: https://docs.pylonsync.com