@@ -782,6 +782,7 @@ export async function buildDeckPreview(target: string, opts: { cwd?: string } =
  */
 export async function runPreview(irPath: string, outDir: string, opts: PreviewOptions = {}): Promise<string> {
   const { ir, svgs, normalized } = await renderDeckSlides(irPath, { cwd: opts.cwd })
+  // After render, not before (S1 review carry) — see this function's own doc comment.
   await mkdir(outDir, { recursive: true })
   for (let i = 0; i < ir.slides.length; i++) {
     const name = `${String(i + 1).padStart(3, "0")}-${ir.slides[i]!.type}.svg`
 
@@ -24,6 +24,14 @@ const VALID_IR = {
 // out of createServeServer's own initial build.
 const INVALID_IR_SHAPE = { version: "4" }
 
+// 1x1 red PNG — the same fixture commands.test.ts uses to exercise a real
+// deck-dir `assets/` asset (see its own "assets/ auto-registration reaches
+// rendered output" describe block).
+const PNG_1PX = Buffer.from(
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
+  "base64",
+)
+
 function makeDir(prefix = "pptfast-serve-"): Promise<string> {
   return mkdtemp(join(tmpdir(), prefix))
 }
@@ -293,6 +301,57 @@ describe("createServeServer — watch + rebuild (deck project directory)", () =>
     expect(recovered.body).toContain("recovered draft")
     sse.close()
   })
+
+  // S1 review carry: task S1's own watch-coverage tests only exercised
+  // pages/*.json — these two round out the other two watch roots
+  // (`watchRoots`, `./serve.ts`) with dedicated coverage of their own.
+
+  it("rebuilds when a file appears inside assets/ (dedicated assets/ watch coverage)", async () => {
+    const deckDir = await makeDir()
+    await writeFile(join(deckDir, "deck.spec.json"), JSON.stringify(makeDeckPlan()))
+    await mkdir(join(deckDir, "pages"))
+    await writeFile(
+      join(deckDir, "pages", "p-a.json"),
+      JSON.stringify({ components: [{ type: "image", asset_id: "logo" }] }),
+    )
+    await mkdir(join(deckDir, "assets"))
+    await writeFile(join(deckDir, "assets", "logo.png"), PNG_1PX)
+    const handle = await startServe(deckDir)
+    const initial = await get(handle.port, "/")
+    expect(initial.body).toContain("data:image/png;base64")
+
+    const sse = connectSSE(handle.port)
+    // A second, unreferenced file — this test's only job is proving the
+    // assets/ *directory* is watched at all (task S1's own coverage was
+    // pages/*.json only), not re-proving asset-content resolution
+    // (commands.test.ts's "assets/ auto-registration reaches rendered
+    // output" already covers that).
+    await writeFile(join(deckDir, "assets", "extra.png"), PNG_1PX)
+    await sse.waitFor("reload")
+    sse.close()
+  })
+
+  it("rebuilds when only deck.spec.json changes, with no pages/ edit", async () => {
+    const deckDir = await makeDir()
+    await writeFile(join(deckDir, "deck.spec.json"), JSON.stringify(makeDeckPlan()))
+    await mkdir(join(deckDir, "pages"))
+    await writeFile(
+      join(deckDir, "pages", "p-a.json"),
+      JSON.stringify({ components: [{ type: "paragraph", text: "steady content" }] }),
+    )
+    const handle = await startServe(deckDir)
+    const initial = await get(handle.port, "/")
+    expect(initial.body).toContain("serve-deck")
+
+    const sse = connectSSE(handle.port)
+    const renamedPlan = { ...makeDeckPlan(), filename: "serve-deck-renamed" }
+    await writeFile(join(deckDir, "deck.spec.json"), JSON.stringify(renamedPlan))
+    await sse.waitFor("reload")
+
+    const revised = await get(handle.port, "/")
+    expect(revised.body).toContain("serve-deck-renamed")
+    sse.close()
+  })
 })
 
 describe("createServeServer — rebuild()", () => {
 
@@ -206,6 +206,13 @@ export async function createServeServer(options: ServeOptions): Promise<ServeHan
       // (nothing filled in, no local images) — nothing to watch there until
       // it's created, not a reason to fail serve startup. Anything other
       // than "doesn't exist yet" (permissions, ...) is a real problem.
+      // Consequence (S1 review carry): this watch-setup pass only ever runs
+      // once, at `createServeServer` call time — a directory that gets
+      // created *later* in the same session (e.g. the first local image
+      // asset is added, materializing `assets/` mid-edit) is never picked
+      // up, since nothing here re-scans for newly-appeared watch roots
+      // afterward. Changes under such a directory go unnoticed until the
+      // user restarts `pptfast serve`.
       if ((e as NodeJS.ErrnoException).code !== "ENOENT") throw e
     }
   }
@@ -248,6 +255,28 @@ export async function createServeServer(options: ServeOptions): Promise<ServeHan
     teardownWatchersAndTimers()
     for (const res of sseClients) res.end()
     sseClients.clear()
+    // `res.end()` above finishes each SSE response, but the socket behind a
+    // `Connection: keep-alive` response (`GET /events`'s own header) is not
+    // guaranteed to be released the instant the response ends —
+    // `server.close()`'s callback only fires once every socket the server
+    // ever accepted has actually closed, so a lingering keep-alive socket
+    // can otherwise leave it hanging indefinitely (S1 review carry).
+    // `closeIdleConnections`/`closeAllConnections` ("http: added connection
+    // closing methods", nodejs/node#42812) exist since Node 18.2.0 — this
+    // repo's actual floor is 18.0.0 (package.json#engines: ">=18"), hence
+    // the `typeof` guard rather than a direct call. Calling both
+    // unconditionally on every Node 18+ patch is deliberate, not redundant
+    // belt-and-suspenders: Node's own `close()` briefly, accidentally
+    // auto-invoked `closeIdleConnections()` internally on some Node 18.x
+    // releases — a v19-only behavior mistakenly backported and later
+    // reverted (nodejs/node#52336, landed 18.20.3: "closeIdleConnections
+    // should not be called while server.close in node v18. This behavior is
+    // for node v19 and above") — so whether `close()` alone is already
+    // sufficient varies by exact patch and cannot be assumed; calling both
+    // methods explicitly here is correct on every patch, a harmless no-op
+    // wherever `close()` already handled it.
+    if (typeof server.closeIdleConnections === "function") server.closeIdleConnections()
+    if (typeof server.closeAllConnections === "function") server.closeAllConnections()
     await new Promise<void>((resolveClose, rejectClose) => {
       server.close((err) => (err ? rejectClose(err) : resolveClose()))
     })