@supatype/cli 0.1.0-alpha.6 → 0.1.0-alpha.7

package/tests/app-command.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import { mkdirSync, rmSync, readFileSync, existsSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { spawnSync } from "node:child_process"
+import { resolve, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+import { scaffold } from "../src/commands/init.js"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const CLI_BIN = resolve(__dirname, "../bin/supatype.js")
+
+function runCli(cwd: string, args: string[]): { stdout: string; stderr: string; exitCode: number } {
+  const result = spawnSync(process.execPath, [CLI_BIN, ...args], {
+    encoding: "utf8",
+    cwd,
+    timeout: 10_000,
+  })
+  return {
+    stdout: String(result.stdout ?? ""),
+    stderr: String(result.stderr ?? ""),
+    exitCode: result.status ?? 1,
+  }
+}
+
+let tmpRoot: string
+
+beforeEach(() => {
+  tmpRoot = join(tmpdir(), `dt-app-test-${Date.now()}`)
+  mkdirSync(tmpRoot, { recursive: true })
+  scaffold(tmpRoot, "app-test")
+})
+
+afterEach(() => {
+  rmSync(tmpRoot, { recursive: true, force: true })
+})
+
+describe("supatype app add --static", () => {
+  it("sets app.mode=static and static_dir in supatype.config.ts", () => {
+    const { exitCode } = runCli(tmpRoot, ["app", "add", "--static", "./public"])
+    expect(exitCode).toBe(0)
+    const config = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(config).toContain('mode: "static"')
+    expect(config).toContain('static_dir: "./public"')
+  })
+
+  it("creates the static directory when missing", () => {
+    const siteDir = join(tmpRoot, "site")
+    expect(existsSync(siteDir)).toBe(false)
+    const { exitCode } = runCli(tmpRoot, ["app", "add", "--static", "./site"])
+    expect(exitCode).toBe(0)
+    expect(existsSync(siteDir)).toBe(true)
+  })
+})

package/tests/augmentation-generator.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest"
+import { generateClientAugmentation } from "../src/augmentation-generator.js"
+
+describe("generateClientAugmentation", () => {
+  it("emits deterministic output independent of model order", () => {
+    const astA = {
+      models: [
+        { tableName: "post", fields: { title: { kind: "text", required: true } } },
+        { tableName: "comment", fields: { body: { kind: "text", required: true } } },
+      ],
+    }
+    const astB = {
+      models: [
+        { tableName: "comment", fields: { body: { kind: "text", required: true } } },
+        { tableName: "post", fields: { title: { kind: "text", required: true } } },
+      ],
+    }
+
+    expect(generateClientAugmentation(astA)).toEqual(generateClientAugmentation(astB))
+  })
+
+  it("marks Insert fields optional when serverGenerated or default is set", () => {
+    const ast = {
+      models: [
+        {
+          tableName: "widget",
+          fields: {
+            id: { kind: "uuid", pgType: "UUID", required: true, primaryKey: true, default: { kind: "genRandomUuid" } },
+            name: { kind: "text", pgType: "TEXT", required: true },
+            created_at: { kind: "text", pgType: "TEXT", required: true, serverGenerated: true },
+          },
+        },
+      ],
+    }
+    const out = generateClientAugmentation(ast)
+    const insertOnly = out.split("Update:")[0] ?? out
+    expect(insertOnly).toContain("id?:")
+    expect(insertOnly).toContain("created_at?:")
+    expect(insertOnly).toContain("name: string")
+    expect(insertOnly).not.toContain("name?:")
+  })
+
+  it("types richText fields as SerializedEditorState", () => {
+    const ast = {
+      models: [
+        {
+          tableName: "note",
+          fields: {
+            id: { kind: "uuid", pgType: "UUID", required: true, primaryKey: true, default: { kind: "genRandomUuid" } },
+            body: { kind: "richText", pgType: "JSONB", required: true },
+          },
+        },
+      ],
+    }
+    const out = generateClientAugmentation(ast)
+    expect(out).toContain('import("@supatype/types/lexical").SerializedEditorState')
+    expect(out).not.toMatch(/body: Record<string, unknown>/)
+  })
+})

package/tests/binary-cache-cloud-overrides.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import { mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import {
+  hasMeaningfulOverrides,
+  isLinkedToCloudProject,
+  resolveBinary,
+  VERSION_PIN_LOCAL,
+  describeActiveOverrides,
+} from "../src/binary-cache.js"
+import type { SupatypeProjectConfig } from "../src/project-config.js"
+
+function baseConfig(overrides?: SupatypeProjectConfig["overrides"]): SupatypeProjectConfig {
+  return {
+    project: { name: "t" },
+    database: { provider: "native" },
+    server: { mode: "dev" },
+    app: { mode: "none" },
+    versions: { engine: "0.1.0", server: "0.1.0", postgres: "17", deno: "2.0.0" },
+    ...(overrides !== undefined ? { overrides } : {}),
+  }
+}
+
+let tmp: string
+beforeEach(() => {
+  tmp = join(tmpdir(), `dt-bc-${Date.now()}`)
+  mkdirSync(join(tmp, ".supatype"), { recursive: true })
+})
+afterEach(() => {
+  rmSync(tmp, { recursive: true, force: true })
+})
+
+describe("hasMeaningfulOverrides", () => {
+  it("is false without overrides", () => {
+    expect(hasMeaningfulOverrides(baseConfig())).toBe(false)
+  })
+  it("is false for empty strings only", () => {
+    expect(hasMeaningfulOverrides(baseConfig({ engine: "  " }))).toBe(false)
+  })
+  it("is true when any path is non-empty", () => {
+    expect(hasMeaningfulOverrides(baseConfig({ engine: "/x/y" }))).toBe(true)
+  })
+})
+
+describe("isLinkedToCloudProject", () => {
+  it("is true when project.ref is set", () => {
+    const cfg = baseConfig()
+    cfg.project.ref = "my-slug"
+    expect(isLinkedToCloudProject(tmp, cfg)).toBe(true)
+  })
+  it("is true when .supatype/cloud.json has projectSlug", () => {
+    writeFileSync(
+      join(tmp, ".supatype", "cloud.json"),
+      JSON.stringify({ apiUrl: "x", token: "t", projectSlug: "p" }),
+    )
+    expect(isLinkedToCloudProject(tmp, baseConfig())).toBe(true)
+  })
+  it("is true when .supatype/linked.json has ref", () => {
+    writeFileSync(join(tmp, ".supatype", "linked.json"), JSON.stringify({ ref: "r1" }))
+    expect(isLinkedToCloudProject(tmp, baseConfig())).toBe(true)
+  })
+  it("is false with token-only cloud.json", () => {
+    writeFileSync(join(tmp, ".supatype", "cloud.json"), JSON.stringify({ apiUrl: "x", token: "t" }))
+    expect(isLinkedToCloudProject(tmp, baseConfig())).toBe(false)
+  })
+})
+
+describe("resolveBinary + cloud link", () => {
+  const prevCwd = process.cwd()
+
+  beforeEach(() => {
+    process.chdir(tmp)
+  })
+  afterEach(() => {
+    process.chdir(prevCwd)
+  })
+
+  it("rejects any meaningful overrides when cloud.json is linked", async () => {
+    writeFileSync(
+      join(tmp, ".supatype", "cloud.json"),
+      JSON.stringify({ apiUrl: "x", token: "t", projectSlug: "p" }),
+    )
+    const cfg = baseConfig({ studio: "/does/not/need/to/exist/for/early/throw" })
+    await expect(resolveBinary("engine", cfg)).rejects.toThrow(/linked to Supatype Cloud/)
+  })
+})
+
+describe("VERSION_PIN_LOCAL + resolveBinary", () => {
+  const prevCwd = process.cwd()
+
+  beforeEach(() => {
+    process.chdir(tmp)
+  })
+  afterEach(() => {
+    process.chdir(prevCwd)
+  })
+
+  it("throws when versions.engine is local without overrides.engine", async () => {
+    const cfg = baseConfig()
+    cfg.versions.engine = VERSION_PIN_LOCAL
+    await expect(resolveBinary("engine", cfg)).rejects.toThrow(/overrides\.engine/)
+  })
+
+  it("uses overrides.engine when versions.engine is local", async () => {
+    const fakeBin = join(tmp, "supatype-engine-local")
+    writeFileSync(fakeBin, "#")
+    const cfg = baseConfig({ engine: fakeBin })
+    cfg.versions.engine = VERSION_PIN_LOCAL
+    const p = await resolveBinary("engine", cfg)
+    expect(p.replace(/\\/g, "/")).toContain("supatype-engine-local")
+  })
+})
+
+describe("describeActiveOverrides", () => {
+  it("lists non-empty override paths", () => {
+    const lines = describeActiveOverrides(
+      baseConfig({ engine: "/a/b", server: "/c/d" }),
+    )
+    expect(lines.some((l) => l.includes("engine"))).toBe(true)
+    expect(lines.some((l) => l.includes("/a/b"))).toBe(true)
+  })
+})

package/tests/cached-artifact-format.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, it } from "vitest"
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import {
+  validateArtifactFormat,
+  type Component,
+  type PlatformId,
+} from "../src/binary-cache.js"
+
+function writeMagic(name: string, bytes: number[]): string {
+  const dir = mkdtempSync(join(tmpdir(), "supatype-artifact-"))
+  const path = join(dir, name)
+  writeFileSync(path, Buffer.from(bytes))
+  return path
+}
+
+function expectValid(component: Component, path: string, platform: PlatformId): void {
+  expect(() => validateArtifactFormat(component, path, platform)).not.toThrow()
+}
+
+function expectInvalid(component: Component, path: string, platform: PlatformId): void {
+  expect(() => validateArtifactFormat(component, path, platform)).toThrow()
+}
+
+describe("validateArtifactFormat", () => {
+  const paths: string[] = []
+
+  afterEach(() => {
+    for (const p of paths) {
+      try {
+        rmSync(join(p, ".."), { recursive: true, force: true })
+      } catch {
+        /* ignore */
+      }
+    }
+    paths.length = 0
+  })
+
+  it("accepts ELF for engine/server/deno on linux", () => {
+    const linux: PlatformId = { os: "linux", arch: "amd64" }
+    for (const component of ["engine", "server", "deno"] as const) {
+      const p = writeMagic(component, [0x7f, 0x45, 0x4c, 0x46, 0, 0, 0, 0])
+      paths.push(p)
+      expectValid(component, p, linux)
+    }
+  })
+
+  it("accepts Mach-O for engine on darwin", () => {
+    const p = writeMagic("engine", [0xcf, 0xfa, 0xed, 0xfe, 0, 0, 0, 0])
+    paths.push(p)
+    expectValid("engine", p, { os: "darwin", arch: "arm64" })
+  })
+
+  it("accepts PE for deno on windows", () => {
+    const p = writeMagic("deno.exe", [0x4d, 0x5a, 0x90, 0x00, 0, 0, 0, 0])
+    paths.push(p)
+    expectValid("deno", p, { os: "windows", arch: "amd64" })
+  })
+
+  it("rejects Go c-archive for server on linux", () => {
+    const p = writeMagic("server", [0x21, 0x3c, 0x61, 0x72, 0, 0, 0, 0])
+    paths.push(p)
+    expectInvalid("server", p, { os: "linux", arch: "amd64" })
+  })
+
+  it("accepts gzip for postgres on linux", () => {
+    const p = writeMagic("pg.tar.gz", [0x1f, 0x8b, 0x08, 0x00, 0, 0, 0, 0])
+    paths.push(p)
+    expectValid("postgres", p, { os: "linux", arch: "amd64" })
+  })
+
+  it("accepts zip for postgres on windows", () => {
+    const p = writeMagic("pg.zip", [0x50, 0x4b, 0x03, 0x04, 0, 0, 0, 0])
+    paths.push(p)
+    expectValid("postgres", p, { os: "windows", arch: "amd64" })
+  })
+
+  it("rejects gzip postgres artifact on windows", () => {
+    const p = writeMagic("pg.tar.gz", [0x1f, 0x8b, 0x08, 0x00, 0, 0, 0, 0])
+    paths.push(p)
+    expectInvalid("postgres", p, { os: "windows", arch: "amd64" })
+  })
+})

package/tests/cli-help.test.ts

@@ -27,7 +27,22 @@ describe("CLI binary (requires built dist/)", () => {
   it("--help lists all top-level commands", () => {
     const { stdout, exitCode } = runCli(["--help"])
     expect(exitCode).toBe(0)
-    const commands = ["init", "dev", "push", "diff", "pull", "generate", "migrate", "rollback", "reset", "seed", "keys", "app", "self-host"]
+    const commands = [
+      "init",
+      "dev",
+      "push",
+      "diff",
+      "pull",
+      "generate",
+      "migrate",
+      "rollback",
+      "reset",
+      "seed",
+      "keys",
+      "app",
+      "self-host",
+      "self-update",
+    ]
     for (const cmd of commands) {
       expect(stdout, `Expected '${cmd}' in --help output`).toContain(cmd)
     }
@@ -39,6 +54,12 @@ describe("CLI binary (requires built dist/)", () => {
     expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+/)
   })
 
+  it("self-update --help describes the command", () => {
+    const { stdout, exitCode } = runCli(["self-update", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout.toLowerCase()).toMatch(/npm|update/)
+  })
+
   it("init --help describes the init command", () => {
     const { stdout, exitCode } = runCli(["init", "--help"])
     expect(exitCode).toBe(0)
@@ -58,10 +79,10 @@ describe("CLI binary (requires built dist/)", () => {
     expect(stdout).toContain("dry run")
   })
 
-  it("pull --help shows --output option", () => {
+  it("pull --help describes deprecated pull command", () => {
     const { stdout, exitCode } = runCli(["pull", "--help"])
     expect(exitCode).toBe(0)
-    expect(stdout).toContain("--output")
+    expect(stdout).toContain("deprecated")
   })
 
   it("reset --help shows --yes flag", () => {
@@ -77,27 +98,32 @@ describe("CLI binary (requires built dist/)", () => {
     expect(stdout).toContain("remove")
   })
 
-  it("app add --help shows --dockerfile and --port options", () => {
+  it("app add --help shows --static and --port options", () => {
     const { stdout, exitCode } = runCli(["app", "add", "--help"])
     expect(exitCode).toBe(0)
-    expect(stdout).toContain("--dockerfile")
+    expect(stdout).toContain("--static")
     expect(stdout).toContain("--port")
   })
 
-  it("self-host --help describes the self-host command", () => {
+  it("self-host --help shows compose only (legacy commands hidden)", () => {
     const { stdout, exitCode } = runCli(["self-host", "--help"])
     expect(exitCode).toBe(0)
-    expect(stdout).toContain("setup")
-    expect(stdout).toContain("status")
-    expect(stdout).toContain("logs")
-    expect(stdout).toContain("backup")
-    expect(stdout).toContain("update")
+    const commandsSection = stdout.split("Commands:")[1] ?? ""
+    expect(commandsSection).toContain("compose")
+    expect(commandsSection).not.toContain("install-service")
+    expect(commandsSection).not.toContain("native")
+    expect(commandsSection).not.toContain("backup")
+    expect(stdout).not.toContain("--output-dir")
   })
 
-  it("self-host setup --help shows --domain option", () => {
-    const { stdout, exitCode } = runCli(["self-host", "setup", "--help"])
+  it("self-host compose --help shows compose subcommands", () => {
+    const { stdout, exitCode } = runCli(["self-host", "compose", "--help"])
     expect(exitCode).toBe(0)
-    expect(stdout).toContain("--domain")
+    expect(stdout).toContain("render")
+    expect(stdout).toContain("up")
+    expect(stdout).toContain("down")
+    expect(stdout).toContain("status")
+    expect(stdout).toContain("logs")
   })
 
   it("unknown command exits non-zero", () => {

package/tests/config.test.ts

@@ -3,13 +3,26 @@ import { mkdirSync, rmSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
 import { tmpdir } from "node:os"
 import { defineConfig, loadConfig } from "../src/config.js"
-import type { DefinatypeConfig } from "../src/config.js"
+import { mergeProjectConfig, type SupatypeProjectConfig } from "../src/project-config.js"
+import { DENO_RELEASE_PIN } from "../src/release-pins.js"
 
 let counter = 0
 let tmpDir: string
 
+const minimalProject = (name: string): SupatypeProjectConfig => ({
+  project: { name },
+  database: { provider: "docker" },
+  server: { mode: "dev" },
+  app: { mode: "none" },
+  versions: {
+    engine: "0.4.2",
+    server: "0.1.0",
+    postgres: "17.2",
+    deno: DENO_RELEASE_PIN,
+  },
+})
+
 beforeEach(() => {
-  // Counter prevents timestamp collisions when tests run in rapid succession
   tmpDir = join(tmpdir(), `dt-config-test-${Date.now()}-${++counter}`)
   mkdirSync(tmpDir, { recursive: true })
 })
@@ -20,17 +33,18 @@ afterEach(() => {
 
 describe("defineConfig()", () => {
   it("returns its argument unchanged (identity helper for type inference)", () => {
-    const cfg: DefinatypeConfig = {
+    const cfg = defineConfig({
+      ...minimalProject("test"),
       connection: "postgresql://localhost/test",
-      schema: "./schema/index.ts",
-    }
+      schema: { path: "./schema/index.ts" },
+    })
     expect(defineConfig(cfg)).toBe(cfg)
   })
 
   it("preserves optional output field", () => {
     const cfg = defineConfig({
-      connection: "postgresql://localhost/test",
-      schema: "./schema/index.ts",
+      ...minimalProject("test"),
+      schema: { path: "./schema/index.ts" },
       output: { types: "./src/types.d.ts", client: "./src/client.ts" },
     })
     expect(cfg.output?.types).toBe("./src/types.d.ts")
@@ -40,62 +54,83 @@ describe("defineConfig()", () => {
 
 describe("loadConfig()", () => {
   it("throws when no config file exists in the directory", () => {
-    expect(() => loadConfig(tmpDir)).toThrow(/No supatype.config.ts found/)
+    expect(() => loadConfig(tmpDir)).toThrow(/No supatype.config.ts/)
   })
 
   it("loads a valid supatype.config.ts (plain export default, no package imports)", () => {
-    // Note: avoid importing @supatype/cli inside the temp config —
-    // the temp dir is outside the monorepo and can't resolve workspace packages.
+    const body = {
+      ...minimalProject("mydb"),
+      connection: "postgresql://localhost/mydb",
+      schema: { path: "./schema/index.ts" },
+    }
     writeFileSync(
       join(tmpDir, "supatype.config.ts"),
-      `export default {
-  connection: "postgresql://localhost/mydb",
-  schema: "./schema/index.ts",
-}
+      `export default ${JSON.stringify(body)}
 `,
     )
     const cfg = loadConfig(tmpDir)
     expect(cfg.connection).toBe("postgresql://localhost/mydb")
-    expect(cfg.schema).toBe("./schema/index.ts")
+    expect(cfg.schema?.path).toBe("./schema/index.ts")
   })
 
-  it("loads a supatype.config.js (plain ESM)", () => {
+  it("normalizes shorthand schema string to { path, pg_schema }", () => {
     writeFileSync(
-      join(tmpDir, "supatype.config.js"),
-      `export default {
-  connection: "postgresql://localhost/jsdb",
-  schema: "./schema/index.ts",
-}
+      join(tmpDir, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        ...minimalProject("x"),
+        schema: "./schema/index.ts",
+      })}
 `,
     )
     const cfg = loadConfig(tmpDir)
-    expect(cfg.connection).toBe("postgresql://localhost/jsdb")
+    expect(cfg.schema?.path).toBe("./schema/index.ts")
+    expect(cfg.schema?.pg_schema).toBe("public")
   })
 
-  it("throws if config is missing the schema field", () => {
+  it("loads a supatype.config.js (plain ESM)", () => {
     writeFileSync(
-      join(tmpDir, "supatype.config.ts"),
-      `export default { connection: "postgresql://localhost/test" }`,
+      join(tmpDir, "supatype.config.js"),
+      `export default ${JSON.stringify({
+        ...minimalProject("jsdb"),
+        connection: "postgresql://localhost/jsdb",
+        schema: { path: "./schema/index.ts" },
+      })}
+`,
     )
-    expect(() => loadConfig(tmpDir)).toThrow(/must export/)
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.connection).toBe("postgresql://localhost/jsdb")
   })
 
-  it("throws if config is missing the connection field", () => {
+  it("throws if config is missing the versions section", () => {
     writeFileSync(
       join(tmpDir, "supatype.config.ts"),
-      `export default { schema: "./schema/index.ts" }`,
+      `export default {
+  project: { name: "t" },
+  database: { provider: "docker" },
+  server: { mode: "dev" },
+  app: { mode: "none" },
+  schema: { path: "./schema/index.ts" },
+}`,
     )
-    expect(() => loadConfig(tmpDir)).toThrow(/must export/)
+    expect(() => loadConfig(tmpDir)).toThrow(/versions/)
   })
 
   it("prefers supatype.config.ts over supatype.config.js when both exist", () => {
     writeFileSync(
       join(tmpDir, "supatype.config.ts"),
-      `export default { connection: "postgresql://localhost/from-ts", schema: "./schema/index.ts" }`,
+      `export default ${JSON.stringify({
+        ...minimalProject("from-ts"),
+        connection: "postgresql://localhost/from-ts",
+        schema: { path: "./schema/index.ts" },
+      })}`,
     )
     writeFileSync(
       join(tmpDir, "supatype.config.js"),
-      `export default { connection: "postgresql://localhost/from-js", schema: "./schema/index.ts" }`,
+      `export default ${JSON.stringify({
+        ...minimalProject("from-js"),
+        connection: "postgresql://localhost/from-js",
+        schema: { path: "./schema/index.ts" },
+      })}`,
     )
     const cfg = loadConfig(tmpDir)
     expect(cfg.connection).toContain("from-ts")
@@ -104,14 +139,82 @@ describe("loadConfig()", () => {
   it("supports optional output field in config", () => {
     writeFileSync(
       join(tmpDir, "supatype.config.ts"),
-      `export default {
-  connection: "postgresql://localhost/test",
-  schema: "./schema/index.ts",
-  output: { types: "./src/types.d.ts" },
-}
-`,
+      `export default ${JSON.stringify({
+        ...minimalProject("t"),
+        schema: { path: "./schema/index.ts" },
+        output: { types: "./src/types.d.ts" },
+      })}`,
     )
     const cfg = loadConfig(tmpDir)
     expect(cfg.output?.types).toBe("./src/types.d.ts")
   })
+
+  it("merges supatype.local.config.ts over base", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        ...minimalProject("base"),
+        schema: { path: "./a.ts" },
+        versions: {
+          engine: "0.4.0",
+          server: "0.1.0",
+          postgres: "17",
+          deno: "2.2.0",
+        },
+      })}`,
+    )
+    writeFileSync(
+      join(tmpDir, "supatype.local.config.ts"),
+      `export default ${JSON.stringify({
+        versions: {
+          engine: "0.4.2",
+          server: "0.1.0",
+          postgres: "17",
+          deno: "2.2.0",
+        },
+      })}`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.versions.engine).toBe("0.4.2")
+    expect(cfg.schema?.path).toBe("./a.ts")
+  })
+})
+
+describe("mergeProjectConfig()", () => {
+  it("deep-merges email.smtp between base and local", () => {
+    const base = defineConfig({
+      ...minimalProject("p"),
+      email: { provider: "smtp", smtp: { host: "h1", port: 587, user: "u0" } },
+    })
+    const merged = mergeProjectConfig(base, { email: { smtp: { host: "h2", pass: "x" } } })
+    expect(merged.email?.provider).toBe("smtp")
+    expect(merged.email?.smtp?.host).toBe("h2")
+    expect(merged.email?.smtp?.port).toBe(587)
+    expect(merged.email?.smtp?.user).toBe("u0")
+    expect(merged.email?.smtp?.pass).toBe("x")
+  })
+
+  it("merges send_email_hook fields from local", () => {
+    const base = defineConfig({
+      ...minimalProject("p"),
+      email: { provider: "console", send_email_hook: true, send_email_hook_uri: "http://old/hook" },
+    })
+    const merged = mergeProjectConfig(base, {
+      email: { send_email_hook_secrets: "v1,whsec_customsecret0000000000000000" },
+    })
+    expect(merged.email?.send_email_hook).toBe(true)
+    expect(merged.email?.send_email_hook_uri).toBe("http://old/hook")
+    expect(merged.email?.send_email_hook_secrets).toBe("v1,whsec_customsecret0000000000000000")
+  })
+
+  it("overrides app.vite_dev_url from local", () => {
+    const base = defineConfig({
+      ...minimalProject("p"),
+      app: { mode: "static", static_dir: "./dist", vite_dev_url: "http://127.0.0.1:1111" },
+    })
+    const merged = mergeProjectConfig(base, { app: { vite_dev_url: "http://127.0.0.1:5173" } })
+    expect(merged.app.vite_dev_url).toBe("http://127.0.0.1:5173")
+    expect(merged.app.mode).toBe("static")
+    expect(merged.app.static_dir).toBe("./dist")
+  })
 })