create-prisma 0.4.1 → 0.4.2-next.37.104.1

package/dist/index.d.mts

@@ -177,13 +177,12 @@ type ErrorMap = { [key in ORPCErrorCode]?: ErrorMapItem<AnySchema> };
 type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
 //#endregion
 //#region src/types.d.ts
-declare const DatabaseProviderSchema: z.ZodEnum<{
+declare const DatabaseProviderSchema: z.ZodPipe<z.ZodEnum<{
+  postgres: "postgres";
   postgresql: "postgresql";
-  mysql: "mysql";
-  sqlite: "sqlite";
-  sqlserver: "sqlserver";
-  cockroachdb: "cockroachdb";
-}>;
+  mongo: "mongo";
+  mongodb: "mongodb";
+}>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>;
 declare const PackageManagerSchema: z.ZodEnum<{
   npm: "npm";
   pnpm: "pnpm";
@@ -191,11 +190,12 @@ declare const PackageManagerSchema: z.ZodEnum<{
   bun: "bun";
   deno: "deno";
 }>;
-declare const SchemaPresetSchema: z.ZodEnum<{
-  empty: "empty";
-  basic: "basic";
+declare const AuthoringStyleSchema: z.ZodEnum<{
+  psl: "psl";
+  typescript: "typescript";
 }>;
 declare const CreateTemplateSchema: z.ZodEnum<{
+  minimal: "minimal";
   hono: "hono";
   elysia: "elysia";
   nest: "nest";
@@ -204,18 +204,20 @@ declare const CreateTemplateSchema: z.ZodEnum<{
   astro: "astro";
   nuxt: "nuxt";
   "tanstack-start": "tanstack-start";
-  turborepo: "turborepo";
 }>;
 declare const DatabaseUrlSchema: z.ZodString;
 declare const CreateCommandInputSchema: z.ZodObject<{
   yes: z.ZodOptional<z.ZodBoolean>;
   verbose: z.ZodOptional<z.ZodBoolean>;
-  provider: z.ZodOptional<z.ZodEnum<{
+  provider: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+    postgres: "postgres";
     postgresql: "postgresql";
-    mysql: "mysql";
-    sqlite: "sqlite";
-    sqlserver: "sqlserver";
-    cockroachdb: "cockroachdb";
+    mongo: "mongo";
+    mongodb: "mongodb";
+  }>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>>;
+  authoring: z.ZodOptional<z.ZodEnum<{
+    psl: "psl";
+    typescript: "typescript";
   }>>;
   packageManager: z.ZodOptional<z.ZodEnum<{
     npm: "npm";
@@ -227,13 +229,11 @@ declare const CreateCommandInputSchema: z.ZodObject<{
   prismaPostgres: z.ZodOptional<z.ZodBoolean>;
   databaseUrl: z.ZodOptional<z.ZodString>;
   install: z.ZodOptional<z.ZodBoolean>;
-  generate: z.ZodOptional<z.ZodBoolean>;
-  schemaPreset: z.ZodOptional<z.ZodEnum<{
-    empty: "empty";
-    basic: "basic";
-  }>>;
+  emit: z.ZodOptional<z.ZodBoolean>;
+  prismaNextVersion: z.ZodOptional<z.ZodString>;
   name: z.ZodOptional<z.ZodString>;
   template: z.ZodOptional<z.ZodEnum<{
+    minimal: "minimal";
     hono: "hono";
     elysia: "elysia";
     nest: "nest";
@@ -242,11 +242,7 @@ declare const CreateCommandInputSchema: z.ZodObject<{
     astro: "astro";
     nuxt: "nuxt";
     "tanstack-start": "tanstack-start";
-    turborepo: "turborepo";
   }>>;
-  skills: z.ZodOptional<z.ZodBoolean>;
-  mcp: z.ZodOptional<z.ZodBoolean>;
-  extension: z.ZodOptional<z.ZodBoolean>;
   force: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type CreateCommandInput = z.infer<typeof CreateCommandInputSchema>;
@@ -256,12 +252,15 @@ declare const router: {
   create: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, zod.ZodOptional<zod.ZodObject<{
     yes: zod.ZodOptional<zod.ZodBoolean>;
     verbose: zod.ZodOptional<zod.ZodBoolean>;
-    provider: zod.ZodOptional<zod.ZodEnum<{
+    provider: zod.ZodOptional<zod.ZodPipe<zod.ZodEnum<{
+      postgres: "postgres";
       postgresql: "postgresql";
-      mysql: "mysql";
-      sqlite: "sqlite";
-      sqlserver: "sqlserver";
-      cockroachdb: "cockroachdb";
+      mongo: "mongo";
+      mongodb: "mongodb";
+    }>, zod.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>>;
+    authoring: zod.ZodOptional<zod.ZodEnum<{
+      psl: "psl";
+      typescript: "typescript";
     }>>;
     packageManager: zod.ZodOptional<zod.ZodEnum<{
       npm: "npm";
@@ -273,13 +272,11 @@ declare const router: {
     prismaPostgres: zod.ZodOptional<zod.ZodBoolean>;
     databaseUrl: zod.ZodOptional<zod.ZodString>;
     install: zod.ZodOptional<zod.ZodBoolean>;
-    generate: zod.ZodOptional<zod.ZodBoolean>;
-    schemaPreset: zod.ZodOptional<zod.ZodEnum<{
-      empty: "empty";
-      basic: "basic";
-    }>>;
+    emit: zod.ZodOptional<zod.ZodBoolean>;
+    prismaNextVersion: zod.ZodOptional<zod.ZodString>;
     name: zod.ZodOptional<zod.ZodString>;
     template: zod.ZodOptional<zod.ZodEnum<{
+      minimal: "minimal";
       hono: "hono";
       elysia: "elysia";
       nest: "nest";
@@ -288,15 +285,11 @@ declare const router: {
       astro: "astro";
       nuxt: "nuxt";
       "tanstack-start": "tanstack-start";
-      turborepo: "turborepo";
     }>>;
-    skills: zod.ZodOptional<zod.ZodBoolean>;
-    mcp: zod.ZodOptional<zod.ZodBoolean>;
-    extension: zod.ZodOptional<zod.ZodBoolean>;
     force: zod.ZodOptional<zod.ZodBoolean>;
   }, zod_v4_core0.$strip>>, Schema<void, void>, MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
 };
 declare function createCreatePrismaCli(): trpc_cli0.TrpcCli;
 declare function create(input?: CreateCommandInput): Promise<void>;
 //#endregion
-export { type CreateCommandInput, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };
+export { AuthoringStyleSchema, type CreateCommandInput, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, create, createCreatePrismaCli, router };

package/dist/index.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { a as DatabaseUrlSchema, i as DatabaseProviderSchema, n as CreateCommandInputSchema, o as PackageManagerSchema, r as CreateTemplateSchema, s as SchemaPresetSchema, t as runCreateCommand } from "./create-H6Tk0JlE.mjs";
+import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as DatabaseUrlSchema, r as CreateCommandInputSchema, s as PackageManagerSchema, t as runCreateCommand } from "./create-BeFhatOc.mjs";
 import { os } from "@orpc/server";
 import { createCli } from "trpc-cli";
 
 //#region src/index.ts
-const CLI_VERSION = "0.4.1";
+const CLI_VERSION = "0.4.2-next.37.104.1";
 const router = os.router({ create: os.meta({
 	description: "Create a new project with Prisma setup",
 	default: true,
@@ -24,4 +24,4 @@ async function create(input = {}) {
 }
 
 //#endregion
-export { CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, router };
+export { AuthoringStyleSchema, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, PackageManagerSchema, create, createCreatePrismaCli, router };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "create-prisma",
-  "version": "0.4.1",
+  "version": "0.4.2-next.37.104.1",
   "private": false,
-  "description": "Create Prisma 7 projects with first-party templates and great DX.",
+  "description": "Create Prisma Next projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",
   "bugs": {
     "url": "https://github.com/prisma/create-prisma/issues"
@@ -36,6 +36,9 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "start": "bun run ./dist/cli.mjs",
+    "test": "bun run test:unit && bun run test:e2e",
+    "test:unit": "bun test ./tests/dependencies.test.ts ./tests/install.test.ts ./tests/telemetry.test.ts",
+    "test:e2e": "bun test --timeout 180000 ./tests/e2e/create-prisma.e2e.test.ts",
     "check": "bun run format:check && bun run lint",
     "lint": "oxlint . --deny-warnings",
     "lint:fix": "oxlint . --fix",
@@ -57,10 +60,12 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@prisma/dev": "0.24.7",
     "@types/bun": "^1.3.9",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^25.3.0",
     "changelogithub": "^14.0.0",
+    "mongodb-memory-server": "11.1.0",
     "oxfmt": "^0.37.0",
     "oxlint": "^1.52.0",
     "tsdown": "^0.20.3",

package/templates/create/_shared/prisma/seed.ts.hbs

@@ -0,0 +1,52 @@
+{{#if (requiresDotenvConfigImport packageManager)}}
+import "dotenv/config";
+{{/if}}
+{{#if (eq template "nuxt")}}
+import { db } from "../server/utils/prisma{{#if (eq packageManager "deno")}}.ts{{/if}}";
+{{else}}
+{{#if (eq template "svelte")}}
+import { db } from "../src/lib/server/prisma{{#if (eq packageManager "deno")}}.ts{{/if}}";
+{{else}}
+{{#if (eq template "tanstack-start")}}
+import { db } from "../src/lib/prisma.server{{#if (eq packageManager "deno")}}.ts{{/if}}";
+{{else}}
+import { db } from "../src/lib/prisma{{#if (eq packageManager "deno")}}.ts{{/if}}";
+{{/if}}
+{{/if}}
+{{/if}}
+
+const seedUsers = [
+  { email: "alice@prisma.io", username: "alice", name: "Alice" },
+  { email: "bob@prisma.io", username: "bob", name: "Bob" },
+  { email: "carol@prisma.io", username: "carol", name: "Carol" },
+];
+
+let createdCount = 0;
+
+{{#if (eq provider "mongo")}}
+try {
+  for (const user of seedUsers) {
+    const existingUser = await db.orm.users.where({ email: user.email }).first();
+    if (!existingUser) {
+      createdCount += await db.orm.users.createCount([user]);
+    }
+  }
+
+  console.log(`Seeded ${createdCount} user${createdCount === 1 ? "" : "s"}.`);
+} finally {
+  await db.close();
+}
+{{else}}
+try {
+  for (const user of seedUsers) {
+    const existingUser = await db.orm.User.where({ email: user.email }).first();
+    if (!existingUser) {
+      createdCount += await db.orm.User.createCount([user]);
+    }
+  }
+
+  console.log(`Seeded ${createdCount} user${createdCount === 1 ? "" : "s"}.`);
+} finally {
+  await db.runtime().close();
+}
+{{/if}}

package/templates/create/astro/README.md.hbs

@@ -9,27 +9,37 @@ Generated by `create-prisma` with the Astro template.
 - `{{runScriptCommand packageManager "preview"}}` - preview the production build
 - `{{runScriptCommand packageManager "astro"}}` - run Astro CLI commands
 
-## Prisma
+## Prisma Next
 
-Prisma setup is scaffolded automatically in:
+Prisma Next setup is scaffolded in:
 
-- `prisma/schema.prisma`
-- `prisma/seed.ts`
+- `prisma/contract{{#if (eq authoring "typescript")}}.ts{{else}}.prisma{{/if}}`
+- `prisma-next.config.ts`
 - `src/lib/prisma.ts`
 - `src/pages/api/users.ts`
-- `prisma.config.ts`
-- `src/generated/prisma`
 
 Database helper scripts are added to `package.json`:
 
-- `db:generate`
-- `db:push`
-- `db:migrate`
-- `db:seed`
-{{#if (eq schemaPreset "basic")}}
-
-The starter page queries a basic `User` model in `src/pages/index.astro`, and `src/pages/api/users.ts` shows an Astro API route backed by the same Prisma client.
+- `{{runScriptCommand packageManager "contract:emit"}}` - emit contract artifacts after contract changes
+{{#if (eq provider "mongo")}}
+- `{{runScriptCommand packageManager "db:up"}}` - start the local MongoDB replica set with `mongodb-memory-server`. Data persists in `.mongo-data/` across restarts.
+- `{{runScriptCommand packageManager "db:down"}}` - stop the local MongoDB process (data preserved)
+- `{{runScriptCommand packageManager "db:reset"}}` - stop and wipe `.mongo-data/` for a clean slate
+- `{{runScriptCommand packageManager "migration:plan"}}` - create a MongoDB migration plan
+- `{{runScriptCommand packageManager "migrate"}}` - apply the planned MongoDB migration
 {{else}}
-
-The starter page keeps the official Astro minimal structure and points you to `prisma/schema.prisma` for your first model.
+- `{{runScriptCommand packageManager "db:init"}}` - initialize database state manually
+- `{{runScriptCommand packageManager "db:update"}}` - update database state manually
+- `{{runScriptCommand packageManager "migration:plan"}}` - create a migration plan
+- `{{runScriptCommand packageManager "migrate"}}` - apply a planned migration
 {{/if}}
+
+- `{{runScriptCommand packageManager "db:seed"}}` - insert sample users manually
+
+For provider-specific Prisma Next reference docs, see `prisma-next.md`. Prisma Next skills live in the upstream `skills/` directory: https://github.com/prisma/prisma-next/tree/main/skills.
+The Astro Vite dev server also auto-emits Prisma Next contract artifacts when the contract changes.
+
+Node-based Prisma Next projects expect Node.js 24 LTS or newer.
+
+The starter page queries a basic `User` model in `src/pages/index.astro`, and `src/pages/api/users.ts` shows an Astro API route backed by the same Prisma Next helper.
+

package/templates/create/astro/astro.config.mjs

@@ -1,5 +1,10 @@
 // @ts-check
+import { prismaVitePlugin } from "@prisma-next/vite-plugin-contract-emit";
 import { defineConfig } from "astro/config";
 
 // https://astro.build/config
-export default defineConfig({});
+export default defineConfig({
+  vite: {
+    plugins: [prismaVitePlugin()],
+  },
+});

package/templates/create/astro/deno.json.hbs

@@ -1,5 +1,5 @@
 {{#if (eq packageManager "deno")}}
 {
-  "nodeModulesDir": "auto"
+  "nodeModulesDir": "manual"
 }
 {{/if}}

package/templates/create/astro/package.json.hbs

@@ -12,11 +12,12 @@
     "astro": "astro"
   },
   "dependencies": {
-    "astro": "^5.17.1"
+    "astro": "^6.3.3"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",
     "tsx": "^4.7.1",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vite": "^7.3.3"
   }
 }

package/templates/create/astro/src/lib/prisma.ts.hbs

@@ -1,53 +1,73 @@
 import "dotenv/config";
-import { PrismaClient } from "../generated/prisma/client";
-{{#if (eq provider "postgresql")}}
-import { PrismaPg } from "@prisma/adapter-pg";
-{{/if}}
-{{#if (eq provider "cockroachdb")}}
-import { PrismaPg } from "@prisma/adapter-pg";
-{{/if}}
-{{#if (eq provider "mysql")}}
-import { PrismaMariaDb } from "@prisma/adapter-mariadb";
-{{/if}}
-{{#if (eq provider "sqlite")}}
-import { PrismaBetterSqlite3 } from "@prisma/adapter-better-sqlite3";
-{{/if}}
-{{#if (eq provider "sqlserver")}}
-import { PrismaMssql } from "@prisma/adapter-mssql";
+{{#if (eq provider "mongo")}}
+import mongo from "@prisma-next/mongo/runtime";
+{{else}}
+import postgres from "@prisma-next/postgres/runtime";
 {{/if}}
 
-{{#if (eq provider "sqlite")}}
-const databaseUrl =
-  import.meta.env?.DATABASE_URL ?? process.env.DATABASE_URL ?? "file:./dev.db";
+{{#if (eq provider "mongo")}}
+import type { DefaultModelRow } from "@prisma-next/mongo-orm";
 {{else}}
-const databaseUrl = import.meta.env?.DATABASE_URL ?? process.env.DATABASE_URL;
-if (!databaseUrl) {
-  throw new Error("DATABASE_URL is required");
-}
+import type { DefaultModelRow } from "@prisma-next/sql-orm-client";
 {{/if}}
 
-{{#if (eq provider "postgresql")}}
-const adapter = new PrismaPg({
-  connectionString: databaseUrl,
+import type { Contract } from "../../prisma/contract.d";
+import contractJson from "../../prisma/contract.json" with { type: "json" };
+
+{{#if (eq provider "mongo")}}
+export const db = mongo<Contract>({
+  contractJson,
+  url: process.env["DATABASE_URL"]!,
 });
-{{/if}}
-{{#if (eq provider "cockroachdb")}}
-const adapter = new PrismaPg({
-  connectionString: databaseUrl,
+{{else}}
+export const db = postgres<Contract>({
+  contractJson,
+  url: process.env["DATABASE_URL"]!,
 });
 {{/if}}
-{{#if (eq provider "mysql")}}
-const adapter = new PrismaMariaDb(databaseUrl);
-{{/if}}
-{{#if (eq provider "sqlite")}}
-const adapter = new PrismaBetterSqlite3({
-  url: databaseUrl,
-});
+
+type UserRow = DefaultModelRow<Contract, "User">;
+
+{{#if (eq provider "mongo")}}
+function toStarterUser(user: Pick<UserRow, "_id" | "email" | "username" | "name">) {
+  return {
+    id: String(user._id),
+    email: user.email,
+    username: user.username ?? null,
+    name: user.name ?? null,
+    createdAt: null as Date | null,
+  };
+}
+{{else}}
+function toStarterUser(user: Pick<UserRow, "id" | "email" | "username" | "name" | "createdAt">) {
+  return {
+    id: String(user.id),
+    email: user.email,
+    username: user.username ?? null,
+    name: user.name ?? null,
+    createdAt: user.createdAt,
+  };
+}
 {{/if}}
-{{#if (eq provider "sqlserver")}}
-const adapter = new PrismaMssql(databaseUrl);
+
+export async function listUsers(limit = 10) {
+
+{{#if (eq provider "mongo")}}
+  const users: ReturnType<typeof toStarterUser>[] = [];
+
+  for await (const user of db.orm.users.select("_id", "email", "username", "name").take(limit).all()) {
+    users.push(toStarterUser(user));
+  }
+
+  return users;
+{{else}}
+  const users = await db.orm.User.select("id", "email", "username", "name", "createdAt").take(limit).all();
+
+  return users.map(toStarterUser);
 {{/if}}
 
-const prisma = new PrismaClient({ adapter });
+}
+
+export type StarterUser = Awaited<ReturnType<typeof listUsers>>[number];
 
-export default prisma;
+export default db;

package/templates/create/astro/src/pages/api/users.ts.hbs

@@ -1,19 +1,12 @@
 import type { APIRoute } from "astro";
-{{#if (eq schemaPreset "basic")}}
-import prisma from "../../lib/prisma";
+
+import { listUsers } from "../../lib/prisma";
 
 export const GET: APIRoute = async () => {
-  const users = await prisma.user
-    .findMany({
-      take: 10,
-      orderBy: {
-        createdAt: "desc",
-      },
-    })
-    .catch((error) => {
-      console.error("Failed to query users:", error);
-      return undefined;
-    });
+  const users = await listUsers(10).catch((error) => {
+    console.error("Failed to query users:", error);
+    return undefined;
+  });
 
   if (!users) {
     return new Response(JSON.stringify({ error: "Could not query users yet." }), {
@@ -30,13 +23,4 @@ export const GET: APIRoute = async () => {
     },
   });
 };
-{{else}}
 
-export const GET: APIRoute = async () => {
-  return new Response(JSON.stringify([]), {
-    headers: {
-      "Content-Type": "application/json",
-    },
-  });
-};
-{{/if}}

package/templates/create/astro/src/pages/index.astro.hbs

@@ -1,21 +1,14 @@
 ---
-{{#if (eq schemaPreset "basic")}}
-import prisma from "../lib/prisma";
+
+import { listUsers } from "../lib/prisma";
 
 const formatter = new Intl.DateTimeFormat("en", {
   dateStyle: "medium",
   timeStyle: "short",
 });
 
-const users = await prisma.user
-  .findMany({
-    take: 10,
-    orderBy: {
-      createdAt: "desc",
-    },
-  })
-  .catch(() => undefined);
-{{/if}}
+const users = await listUsers(10).catch(() => undefined);
+
 ---
 
 <html lang="en">
@@ -29,11 +22,11 @@ const users = await prisma.user
   <body>
     <main class="shell">
       <div class="hero">
-        <p class="eyebrow">Astro + Prisma 7</p>
-{{#if (eq schemaPreset "basic")}}
+        <p class="eyebrow">Astro + Prisma Next</p>
+
         <h1>Users from your database, loaded on the server.</h1>
         <p class="lede">
-          This page reads from <code>src/pages/index.astro</code> using the Prisma instance in
+          This page reads from <code>src/pages/index.astro</code> using the Prisma Next helper in
           <code>src/lib/prisma.ts</code>. An Astro API route is also scaffolded in
           <code>src/pages/api/users.ts</code>.
         </p>
@@ -47,63 +40,32 @@ const users = await prisma.user
 
         {!users ? (
           <p class="empty">
-            Could not query users yet. Run <code>db:migrate</code>, then <code>db:seed</code>,
+            Could not query users yet. Run <code>contract:emit</code> and apply your schema,
             then refresh.
           </p>
         ) : users.length === 0 ? (
-          <p class="empty">No users yet. Run <code>db:seed</code> after your first migration.</p>
+          <p class="empty">No users yet. Run db:seed after applying your first migration.</p>
         ) : (
           <ul class="users">
             {users.map((user) => (
               <li>
                 <div>
                   <strong>{user.name ?? "Unnamed user"}</strong>
-                  <p>{user.email}</p>
+                  <p>{user.username ? `@${user.username}` : user.email}</p>
                 </div>
-                <time datetime={user.createdAt.toISOString()}>
-                  {formatter.format(user.createdAt)}
-                </time>
+                {user.createdAt ? (
+                  <time datetime={user.createdAt.toISOString()}>
+                    {formatter.format(user.createdAt)}
+                  </time>
+                ) : (
+                  <span class="muted">No timestamp</span>
+                )}
               </li>
             ))}
           </ul>
         )}
       </section>
-{{else}}
-        <h1>Your Astro app is ready.</h1>
-        <p class="lede">
-          Edit <code>prisma/schema.prisma</code>, run <code>db:migrate</code>, then load your data
-          in Astro pages or API routes with the Prisma instance in <code>src/lib/prisma.ts</code>.
-        </p>
-      </div>
 
-      <section class="panel">
-        <div class="panel-header">
-          <h2>What's included</h2>
-          <span>Starter kit</span>
-        </div>
-
-        <ul class="users">
-          <li>
-            <div>
-              <strong>Prisma client</strong>
-              <p>Use the shared instance from <code>src/lib/prisma.ts</code>.</p>
-            </div>
-          </li>
-          <li>
-            <div>
-              <strong>API route example</strong>
-              <p>See <code>src/pages/api/users.ts</code> for an Astro server endpoint.</p>
-            </div>
-          </li>
-          <li>
-            <div>
-              <strong>Seed script</strong>
-              <p>Run <code>db:seed</code> after your first migration.</p>
-            </div>
-          </li>
-        </ul>
-      </section>
-{{/if}}
     </main>
   </body>
 </html>
@@ -171,6 +133,7 @@ const users = await prisma.user
 
   .panel-header span,
   .empty,
+  .muted,
   time {
     color: #888;
     font-size: 0.8rem;