@pylonsync/create-pylon 0.19.1 → 0.21.0

package/templates/waitlist/app/icon.svg

@@ -0,0 +1,2 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><rect width="64" height="64" rx="14" fill="#0b0b0c"/>
+<path d="M20 14h9v27h17v9H20z" fill="#4f6bff"/></svg>

package/templates/waitlist/app/login/page.tsx

@@ -18,21 +18,21 @@ export default function LoginPage({ auth, response }: PageProps) {
   if (auth.user_id && !auth.user_id.startsWith("guest_")) response.redirect("/dashboard");
   const { brand } = siteConfig;
   return (
-    <div className="flex min-h-screen items-center justify-center bg-white px-6 py-12">
-      <div className="w-full max-w-[400px] rounded-2xl border border-zinc-200/70 p-8">
-        <Link href="/" className="inline-flex">
-          <span className="flex size-9 items-center justify-center rounded-xl bg-zinc-900 text-base font-bold text-white">
-            {brand.letter}
-          </span>
+    <div className="flex min-h-screen flex-col bg-ink px-6 text-chalk">
+      <div className="mx-auto flex h-16 w-full max-w-5xl items-center">
+        <Link href="/" className="font-display text-[17px] font-bold tracking-tight text-chalk">
+          {brand.name}
         </Link>
-        <h1 className="mt-5 text-[22px] font-semibold tracking-tight text-zinc-900">
-          {brand.name} dashboard
-        </h1>
-        <p className="mt-1 text-[13px] text-zinc-500">
-          Sign in to see who&apos;s on your waitlist.
-        </p>
-        <div className="mt-6">
-          <AuthForm />
+      </div>
+      <div className="flex flex-1 items-center justify-center pb-24">
+        <div className="w-full max-w-[380px]">
+          <h1 className="font-display text-[1.75rem] font-bold leading-tight tracking-[-0.02em]">
+            Sign in to the waitlist
+          </h1>
+          <p className="mt-2 text-[14px] text-chalk-2">Owner access to signups and the export.</p>
+          <div className="mt-8 rounded-lg border border-line bg-paper p-6">
+            <AuthForm />
+          </div>
         </div>
       </div>
     </div>

package/templates/waitlist/app.ts

@@ -44,8 +44,8 @@ const Signup = entity(
 );
 
 // A single-row, PII-FREE aggregate the public page can safely read live. It
-// holds only the signup count — no emails. `joinWaitlist` keeps it in sync with
-// the real Signup count on every new join. The landing page subscribes with
+// holds only the signup count — no emails. Every Signup writer recounts into
+// it (lib/stats.ts → syncWaitlistStat). The landing page subscribes with
 // `db.useQuery("WaitlistStat")`, which syncs across every open tab through the
 // replica — so the counter ticks up everywhere the instant someone joins. This
 // is the cross-tab-safe realtime primitive (entity sync), not a per-connection
@@ -81,9 +81,9 @@ const User = entity(
 // PRIVACY — the heart of the spec. Signup holds visitor emails, so it denies
 // EVERY client read and write. No `db.useQuery("Signup")` can ever pull a row,
 // and no client can insert/update/delete directly. Writes happen only inside
-// the server-side `joinWaitlist` mutation (functions bypass policies); reads
-// happen only inside `waitlistCount` (returns a bare integer) and the
-// owner-gated `waitlistStats`. A marketing site must never leak its own
+// the server-side `joinWaitlist` and dev-only `seedDemo` mutations (functions
+// bypass policies); reads happen only inside the owner-gated `waitlistStats`.
+// The public page sees the count through WaitlistStat. A marketing site must never leak its own
 // customers' emails — this policy is what guarantees it.
 const signupPolicy = policy({
   name: "signup_private",
@@ -96,7 +96,7 @@ const signupPolicy = policy({
 
 // The aggregate count is public to READ (it's just a number — the whole point
 // is that the landing page shows it live to everyone). Clients can't WRITE it;
-// only the joinWaitlist mutation maintains it server-side.
+// only the Signup writers maintain it server-side.
 const waitlistStatPolicy = policy({
   name: "waitlist_stat_public_read",
   entity: "WaitlistStat",

package/templates/waitlist/functions/joinWaitlist.ts

@@ -1,4 +1,5 @@
 import { mutation, v } from "@pylonsync/functions";
+import { syncWaitlistStat } from "../lib/stats";
 
 // Normalize + sanity-check an email without pulling in a dependency. This is a
 // pragmatic "looks like an email" check, not RFC 5322 — the unique index is the
@@ -14,9 +15,8 @@ function normalizeEmail(raw: string): string | null {
 
 // joinWaitlist — the ONLY way a Signup row is ever written. It's a `mutation`
 // (not an `action`): mutations get `ctx.db` access and run as one atomic
-// transaction, and the insert fires a change event that re-runs the live
-// `waitlistCount` query for every open tab — that's what makes the counter tick
-// up in realtime.
+// transaction. It also rewrites the public WaitlistStat row, and that change
+// syncs to every open tab, which is what makes the counter tick up live.
 //
 // `auth: "public"` because a landing-page visitor has no account. Public
 // mutations are still rate-limited at the HTTP layer in production (the
@@ -61,21 +61,9 @@ export default mutation<{ email: string }, { ok: boolean; alreadyJoined: boolean
       throw e;
     }
 
-    // Keep the public, PII-free WaitlistStat singleton in sync with the real
-    // count. We RECOUNT (rather than +1) so the number can never drift, and
-    // this whole handler is one transaction — on SQLite writers serialize, so
-    // the recount-then-write is consistent. The landing page reads this row via
-    // `db.useQuery`, which syncs the new value to every open tab.
-    const total = (await ctx.db.unsafe.list("Signup")).length;
-    const stat = (await ctx.db.unsafe.list("WaitlistStat"))[0] as
-      | { id: string }
-      | undefined;
-    const now = new Date().toISOString();
-    if (stat) {
-      await ctx.db.unsafe.update("WaitlistStat", stat.id, { count: total, updatedAt: now });
-    } else {
-      await ctx.db.unsafe.insert("WaitlistStat", { count: total, updatedAt: now });
-    }
+    // Keep the public, PII-free WaitlistStat row equal to the Signup count.
+    // It is a recount, not +1, so the number cannot drift from the table.
+    await syncWaitlistStat(ctx.db.unsafe);
 
     return { ok: true, alreadyJoined: false };
   },

package/templates/waitlist/functions/seedDemo.ts

@@ -0,0 +1,32 @@
+import { mutation } from "@pylonsync/functions";
+import { demoDataEnabled, demoSignups } from "../lib/demo";
+import { syncWaitlistStat } from "../lib/stats";
+
+// seedDemo — fill an empty waitlist with fictional signups in development.
+//
+// The landing page counter calls this when it finds no signups, and the
+// dashboard calls it once on load. It writes nothing unless demo data is on
+// (lib/demo.ts: PYLON_DEMO_DATA, else a `pylon dev` process), so `pylon start`,
+// Docker, and Pylon Cloud deploys do not get demo rows. It also writes nothing
+// once any Signup exists, so it cannot mix demo rows into a real list. Clearing
+// every signup in development seeds the list again on the next load. The
+// advisory lock stops two first visits from seeding twice.
+//
+// Public because the first visitor in `pylon dev` is anonymous. It returns only
+// a flag, never a row.
+export default mutation<Record<string, never>, { seeded: boolean }>({
+  auth: "public",
+  async handler(ctx) {
+    if (!demoDataEnabled(ctx.env)) return { seeded: false };
+
+    await ctx.db.advisoryLock("waitlist_seed_demo");
+    const existing = await ctx.db.unsafe.list("Signup");
+    if (existing.length > 0) return { seeded: false };
+
+    for (const row of demoSignups(Date.now())) {
+      await ctx.db.unsafe.insert("Signup", { email: row.email, createdAt: row.createdAt });
+    }
+    await syncWaitlistStat(ctx.db.unsafe);
+    return { seeded: true };
+  },
+});

package/templates/waitlist/lib/demo.ts

@@ -0,0 +1,94 @@
+// Demo signups for local development.
+//
+// `pylon dev` fills an empty waitlist with about 180 fictional signups spread
+// over the last 30 days, so the counter, chart, and list have data. A deploy
+// does not seed: `demoDataEnabled` is true only when PYLON_DEMO_DATA is on, or
+// when it is unset and the process runs under `pylon dev`. Set
+// PYLON_DEMO_DATA=0 to turn it off in development too.
+//
+// Pure data + pure shaping, so functions/seedDemo.ts stays a thin wrapper and
+// this file is testable without a server.
+
+const ON = new Set(["1", "true", "yes", "on"]);
+const OFF = new Set(["0", "false", "no", "off"]);
+
+/**
+ * True when demo rows may be written. An explicit PYLON_DEMO_DATA wins.
+ * Otherwise it needs both PYLON_DEV_MODE on and PYLON_DEV_WATCH_DIR set. Only
+ * `pylon dev` sets PYLON_DEV_WATCH_DIR; `pylon start` and the Docker image do
+ * not, and the image turns PYLON_DEV_MODE on by default, so dev mode alone is
+ * not proof of a local machine.
+ */
+export function demoDataEnabled(env: Record<string, string | undefined>): boolean {
+  const explicit = env.PYLON_DEMO_DATA?.trim().toLowerCase();
+  if (explicit && ON.has(explicit)) return true;
+  if (explicit && OFF.has(explicit)) return false;
+  const dev = env.PYLON_DEV_MODE?.trim().toLowerCase();
+  const devMode = dev === "1" || dev === "true";
+  return devMode && Boolean(env.PYLON_DEV_WATCH_DIR?.trim());
+}
+
+const FIRST = [
+  "priya", "marcus", "lena", "tomas", "aisha", "ben", "hana", "diego", "sofia", "kwame",
+  "ingrid", "raj", "noor", "felix", "maya", "owen", "yuki", "carmen", "theo", "amara",
+  "jonas", "leila", "sam", "ines", "dev", "clara", "malik", "rosa", "ethan", "zara",
+];
+const LAST = [
+  "nair", "bell", "fischer", "alvarez", "khan", "osei", "sato", "ruiz", "marin", "mensah",
+  "berg", "patel", "haddad", "wagner", "chen", "reilly", "tanaka", "vega", "park", "okafor",
+];
+// Fictional company domains on the reserved .example TLD, so no demo address
+// can reach a real inbox.
+const DOMAINS = [
+  "fieldnote.example", "northwind.example", "quarry.example", "bluefin.example", "wren.example",
+  "copperline.example", "tidewater.example", "larkspur.example", "kestrel.example", "orchardlabs.example",
+  "sable.example", "ironwood.example", "halcyon.example", "pinecrest.example", "vantage.example",
+];
+
+/** Small deterministic PRNG (mulberry32) so the demo set is stable per seed. */
+function rng(seed: number): () => number {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+export interface DemoSignup {
+  email: string;
+  createdAt: string;
+}
+
+/**
+ * About 180 signups over the 30 days before `nowMs`, rising toward today.
+ * Emails are unique. Every timestamp is in the past.
+ */
+export function demoSignups(nowMs: number, seed = 7): DemoSignup[] {
+  const rand = rng(seed);
+  const out: DemoSignup[] = [];
+  const seen = new Set<string>();
+  const DAY = 86_400_000;
+  for (let daysAgo = 29; daysAgo >= 0; daysAgo--) {
+    // Growth curve: ~2/day a month ago, ~10/day this week, plus noise.
+    const base = 2 + Math.round((29 - daysAgo) * 0.28);
+    const count = Math.max(0, base + Math.round((rand() - 0.5) * 4));
+    for (let i = 0; i < count; i++) {
+      const first = FIRST[Math.floor(rand() * FIRST.length)];
+      const last = LAST[Math.floor(rand() * LAST.length)];
+      const domain = DOMAINS[Math.floor(rand() * DOMAINS.length)];
+      const shape = rand();
+      const local = shape < 0.5 ? `${first}.${last}` : shape < 0.8 ? `${first}` : `${first[0]}${last}`;
+      const email = `${local}@${domain}`;
+      if (seen.has(email)) continue;
+      seen.add(email);
+      // A random minute inside that day, never later than `nowMs`.
+      const offset = Math.floor(rand() * DAY);
+      const ts = Math.min(nowMs - 60_000, nowMs - daysAgo * DAY - offset);
+      out.push({ email, createdAt: new Date(ts).toISOString() });
+    }
+  }
+  return out.sort((a, b) => (a.createdAt < b.createdAt ? -1 : 1));
+}

package/templates/waitlist/lib/launch.ts

@@ -0,0 +1,19 @@
+// The launch line under the hero form, from `siteConfig.hero.launchDate`.
+//
+// Before the date it names the month ("Public launch: March 2027"). From the
+// date on it says invites are going out, so the page never shows a launch date
+// that has already passed. The date is read and formatted in UTC, so the
+// server render and the browser produce the same text.
+
+/** `launchDate` is "YYYY-MM-DD" (UTC). Returns null for a malformed date. */
+export function launchLabel(launchDate: string, nowMs: number): string | null {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(launchDate.trim());
+  if (!m) return null;
+  const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  const atMs = Date.UTC(y, mo - 1, d);
+  const at = new Date(atMs);
+  if (at.getUTCFullYear() !== y || at.getUTCMonth() !== mo - 1 || at.getUTCDate() !== d) return null;
+  if (nowMs >= atMs) return "Invites are going out now";
+  const month = at.toLocaleDateString("en-US", { month: "long", year: "numeric", timeZone: "UTC" });
+  return `Public launch: ${month}`;
+}

package/templates/waitlist/lib/site.config.ts

@@ -36,7 +36,9 @@ export type MockRow = { title: string; tag: string; done?: boolean };
 
 export type WaitlistConfig = BaseConfig & {
   hero: {
-    launchNote: string; // one short line, set in mono: when it ships
+    // "YYYY-MM-DD" (UTC). The page shows the month until this date, then
+    // "Invites are going out now". See lib/launch.ts.
+    launchDate: string;
     headline: string;
     subcopy: string;
     emailPlaceholder: string;
@@ -47,9 +49,11 @@ export type WaitlistConfig = BaseConfig & {
   counter: {
     enabled: boolean;
     label: string; // e.g. "people on the list"
-    // A vanity baseline added to the real, live signup count so a brand-new
-    // page doesn't read "0". Set to 0 to show only genuine signups.
-    seedCount?: number;
+    labelOne: string; // the same label for a count of 1, e.g. "person on the list"
+    // Signups collected before this site existed (an old form, a spreadsheet),
+    // added to the Signup table's count. Keep 0 unless those people are real;
+    // the page shows the sum as one number.
+    importedCount: number;
   };
   // The HTML/CSS product window on the right of the hero. No screenshot.
   mock: {
@@ -93,11 +97,11 @@ export const siteConfig: WaitlistConfig = {
   seo: {
     title: "Lumo — projects, notes, and tasks in one workspace. Coming soon.",
     description:
-      "Lumo puts your projects, notes, and tasks in one workspace. It launches this fall. Join the waitlist for an early invite.",
+      "Lumo puts your projects, notes, and tasks in one workspace. Join the waitlist for an early invite.",
   },
 
   hero: {
-    launchNote: "Launch: fall 2026",
+    launchDate: "2027-03-02",
     headline: "Projects, notes, and tasks in one workspace.",
     subcopy:
       "Lumo is one app for the plan, the notes behind it, and the tasks that come out of it. Join the list and we send an invite before the public launch.",
@@ -110,7 +114,8 @@ export const siteConfig: WaitlistConfig = {
   counter: {
     enabled: true,
     label: "people on the list",
-    seedCount: 1200,
+    labelOne: "person on the list",
+    importedCount: 0,
   },
 
   mock: {
@@ -148,8 +153,8 @@ export const siteConfig: WaitlistConfig = {
     headline: "Questions",
     items: [
       {
-        q: "When does Lumo launch?",
-        a: "Fall 2026. People on the waitlist get an invite before the public launch.",
+        q: "Who gets invited first?",
+        a: "People get invites in the order they joined. Each invite covers one workspace for up to five people.",
       },
       {
         q: "What do I get for joining?",

package/templates/waitlist/lib/stats.ts

@@ -28,3 +28,38 @@ export interface WaitlistStatsData {
 export type WaitlistStatsResult =
   | ({ authorized: true } & WaitlistStatsData)
   | { authorized: false };
+
+/* ------------------------- public live counter ------------------------- */
+
+// The public counter shows the Signup table's row count, read from the
+// PII-free WaitlistStat row. `importedCount` is `siteConfig.counter.importedCount`:
+// signups collected before this site existed (an old form, a spreadsheet). It is
+// 0 by default, so the page shows only rows in the table.
+export function publicCount(
+  statRows: ReadonlyArray<{ count: number }>,
+  importedCount = 0,
+): number {
+  const real = statRows.length > 0 ? Math.max(0, Math.floor(statRows[0].count)) : 0;
+  const imported = Number.isFinite(importedCount) ? Math.max(0, Math.floor(importedCount)) : 0;
+  return real + imported;
+}
+
+// The subset of `ctx.db.unsafe` the recount needs. Typed structurally so the
+// helper runs against the real handle and a test double.
+export interface StatDb {
+  list(entity: string): Promise<unknown[]>;
+  insert(entity: string, data: Record<string, unknown>): Promise<unknown>;
+  update(entity: string, id: string, data: Record<string, unknown>): Promise<unknown>;
+}
+
+// Write the Signup row count into the single WaitlistStat row, creating it if
+// missing. Every writer of Signup calls this in the same transaction, so the
+// public number is always the table's count.
+export async function syncWaitlistStat(db: StatDb): Promise<number> {
+  const total = (await db.list("Signup")).length;
+  const stat = (await db.list("WaitlistStat"))[0] as { id: string } | undefined;
+  const now = new Date().toISOString();
+  if (stat) await db.update("WaitlistStat", stat.id, { count: total, updatedAt: now });
+  else await db.insert("WaitlistStat", { count: total, updatedAt: now });
+  return total;
+}

package/templates/waitlist/tests/counter.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import { publicCount, syncWaitlistStat, type StatDb } from "../lib/stats";
+import { demoDataEnabled, demoSignups } from "../lib/demo";
+import { launchLabel } from "../lib/launch";
+import { siteConfig } from "../lib/site.config";
+
+describe("publicCount", () => {
+  test("is the table's count when nothing is imported", () => {
+    expect(publicCount([{ count: 3 }])).toBe(3);
+    expect(publicCount([])).toBe(0);
+  });
+  test("adds only an explicit, non-negative imported count", () => {
+    expect(publicCount([{ count: 3 }], 40)).toBe(43);
+    expect(publicCount([{ count: 3 }], -5)).toBe(3);
+    expect(publicCount([{ count: 3 }], Number.NaN)).toBe(3);
+  });
+  test("the shipped config adds nothing to the real count", () => {
+    expect(siteConfig.counter.importedCount).toBe(0);
+  });
+});
+
+// An in-memory stand-in for ctx.db.unsafe.
+function fakeDb(signups: number): StatDb & { rows: Record<string, Record<string, unknown>[]> } {
+  const rows: Record<string, Record<string, unknown>[]> = {
+    Signup: Array.from({ length: signups }, (_, i) => ({ id: `s${i}` })),
+    WaitlistStat: [],
+  };
+  return {
+    rows,
+    async list(entity) {
+      return rows[entity] ?? [];
+    },
+    async insert(entity, data) {
+      const id = `${entity}-${rows[entity].length}`;
+      rows[entity].push({ id, ...data });
+      return id;
+    },
+    async update(entity, id, data) {
+      const row = rows[entity].find((r) => r.id === id);
+      if (row) Object.assign(row, data);
+      return id;
+    },
+  };
+}
+
+describe("syncWaitlistStat", () => {
+  test("creates the stat row with the Signup count", async () => {
+    const db = fakeDb(5);
+    expect(await syncWaitlistStat(db)).toBe(5);
+    expect(db.rows.WaitlistStat).toHaveLength(1);
+    expect(db.rows.WaitlistStat[0].count).toBe(5);
+  });
+  test("recounts into the existing row instead of adding one", async () => {
+    const db = fakeDb(5);
+    await syncWaitlistStat(db);
+    db.rows.Signup.push({ id: "late" });
+    await syncWaitlistStat(db);
+    expect(db.rows.WaitlistStat).toHaveLength(1);
+    expect(db.rows.WaitlistStat[0].count).toBe(6);
+  });
+});
+
+describe("demoDataEnabled", () => {
+  test("needs a `pylon dev` process when PYLON_DEMO_DATA is unset", () => {
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "1", PYLON_DEV_WATCH_DIR: "/src/app" })).toBe(true);
+    // The Docker base image turns dev mode on by default; without `pylon dev` it must not seed.
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "true" })).toBe(false);
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "true", PYLON_DEV_WATCH_DIR: "/src/app" })).toBe(true);
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "false" })).toBe(false);
+    expect(demoDataEnabled({})).toBe(false);
+  });
+  test("an explicit PYLON_DEMO_DATA wins", () => {
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "1", PYLON_DEV_WATCH_DIR: "/src/app", PYLON_DEMO_DATA: "0" })).toBe(false);
+    expect(demoDataEnabled({ PYLON_DEV_MODE: "false", PYLON_DEMO_DATA: "1" })).toBe(true);
+  });
+});
+
+describe("demoSignups", () => {
+  const now = Date.parse("2026-09-26T15:00:00Z");
+  const rows = demoSignups(now);
+  test("unique emails, all in the past 30 days", () => {
+    expect(new Set(rows.map((r) => r.email)).size).toBe(rows.length);
+    for (const r of rows) {
+      const t = Date.parse(r.createdAt);
+      expect(t).toBeLessThan(now);
+      expect(t).toBeGreaterThan(now - 31 * 86_400_000);
+    }
+  });
+  test("enough rows to fill the chart, stable for a seed", () => {
+    expect(rows.length).toBeGreaterThan(120);
+    expect(demoSignups(now)).toEqual(rows);
+  });
+});
+
+describe("launchLabel", () => {
+  const now = Date.parse("2026-09-26T12:00:00Z");
+  test("names the month before the date", () => {
+    expect(launchLabel("2027-03-02", now)).toBe("Public launch: March 2027");
+  });
+  test("never shows a date that has passed", () => {
+    expect(launchLabel("2026-09-01", now)).toBe("Invites are going out now");
+  });
+  test("rejects a malformed date", () => {
+    expect(launchLabel("fall 2026", now)).toBeNull();
+    expect(launchLabel("2026-02-31", now)).toBeNull();
+  });
+});

package/templates/waitlist/tests/live-count.test.tsx

@@ -0,0 +1,48 @@
+import { afterEach, expect, mock, test } from "bun:test";
+import React from "react";
+import { cleanup, render, screen } from "@testing-library/react";
+
+// The live count reads the WaitlistStat row. Mock the data boundary so the test
+// controls what the "server" says.
+let statRows: { id: string; count: number; updatedAt: string }[] = [];
+let loading = false;
+mock.module("@pylonsync/react", () => ({
+  db: { useQuery: () => ({ data: statRows, loading }) },
+  callFn: async () => ({ seeded: false }),
+}));
+mock.module("@pylonsync/client", () => ({
+  EnsureGuest: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+}));
+const { LiveCount } = await import("../app/(marketing)/waitlist-hero");
+
+afterEach(() => {
+  cleanup();
+  statRows = [];
+  loading = false;
+});
+
+test("shows the table's count, with no vanity baseline", () => {
+  statRows = [{ id: "w", count: 42, updatedAt: "" }];
+  render(<LiveCount importedCount={0} label="people on the list" labelOne="person on the list" />);
+  expect(screen.getByTestId("live-count").textContent).toBe("42");
+});
+
+test("shows nothing, not a placeholder number, before the first sync", () => {
+  loading = true;
+  render(<LiveCount importedCount={0} label="people on the list" labelOne="person on the list" />);
+  expect(screen.queryByTestId("live-count")).toBeNull();
+});
+
+test("uses the singular label for one signup", () => {
+  statRows = [{ id: "w", count: 1, updatedAt: "" }];
+  const { container } = render(
+    <LiveCount importedCount={0} label="people on the list" labelOne="person on the list" />,
+  );
+  expect(container.textContent).toContain("1person on the list");
+});
+
+test("shows nothing while the list is empty", () => {
+  statRows = [{ id: "w", count: 0, updatedAt: "" }];
+  render(<LiveCount importedCount={0} label="people on the list" labelOne="person on the list" />);
+  expect(screen.queryByTestId("live-count")).toBeNull();
+});

package/templates/ai-chat/tests/example.test.ts

@@ -1,12 +0,0 @@
-import { expect, test } from "bun:test";
-
-// Your first test. Run the suite with:  pylon test  (or: npm test)
-//
-// `pylon test` discovers every *.test.ts file under tests/ (or functions/) and
-// runs it with Bun's test runner against an in-memory Pylon. Replace this
-// placeholder with tests for your functions and helpers — see AGENTS.md →
-// Testing for the pure-logic and HTTP-against-`pylon dev` patterns.
-
-test("placeholder — replace me with a real test", () => {
-  expect(true).toBe(true);
-});

package/templates/backend/consumer/apps/api/functions/feed.ts

@@ -1,57 +0,0 @@
-import { query } from "@pylonsync/functions";
-
-/**
- * Public feed — every Post, newest first. Joins author Profile + the
- * caller's like state into the response so the client can render a
- * row without N+1 follow-up queries.
- *
- * For a real consumer app, paginate this (limit + cursor by createdAt)
- * — the scaffold returns at most 100 rows, which is plenty for a
- * Hello-World feed but unsustainable past a few thousand posts.
- */
-export default query({
-	args: {},
-	async handler(ctx) {
-		const posts = (await ctx.db.query("Post", {})) as any[];
-		const sorted = [...posts]
-			.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt))
-			.slice(0, 100);
-
-		const callerProfile = ctx.auth.userId
-			? ((await ctx.db.query("Profile", {
-					userId: ctx.auth.userId,
-				})) as any[])[0]
-			: null;
-
-		const out: Array<{
-			id: string;
-			body: string;
-			createdAt: string;
-			author: { id: string; handle: string; displayName: string } | null;
-			likeCount: number;
-			likedByMe: boolean;
-		}> = [];
-		for (const p of sorted) {
-			const author = (await ctx.db.get("Profile", p.authorId)) as any;
-			const likes = (await ctx.db.query("Like", { postId: p.id })) as any[];
-			const likedByMe = callerProfile
-				? likes.some((l) => l.profileId === callerProfile.id)
-				: false;
-			out.push({
-				id: p.id,
-				body: p.body,
-				createdAt: p.createdAt,
-				author: author
-					? {
-							id: author.id,
-							handle: author.handle,
-							displayName: author.displayName,
-						}
-					: null,
-				likeCount: likes.length,
-				likedByMe,
-			});
-		}
-		return out;
-	},
-});

package/templates/backend/consumer/apps/api/functions/profilePosts.ts

@@ -1,17 +0,0 @@
-import { query, v } from "@pylonsync/functions";
-
-/**
- * Every Post by a single Profile, newest first. Used by the profile
- * page on each platform.
- */
-export default query({
-	args: { profileId: v.id("Profile") },
-	async handler(ctx, args: { profileId: string }) {
-		const rows = (await ctx.db.query("Post", {
-			authorId: args.profileId,
-		})) as any[];
-		return rows.sort(
-			(a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt),
-		);
-	},
-});