@taskmark/ui 0.1.0 → 0.2.0

package/dist/standalone/lib/taskmark/build-snapshot.ts

@@ -0,0 +1,198 @@
+import fs from "node:fs"
+import path from "node:path"
+
+import { loadWorkItemDetailSync } from "@/lib/taskmark/detail-load"
+import type { WorkItemRef } from "@/lib/taskmark/detail-types"
+import { parseEpicsForProject } from "@/lib/taskmark/parse-epics"
+import { parseWorkItemsForEpic, parseWorkItemsViewForProject } from "@/lib/taskmark/parse-flat-lists"
+import { parseItemsForStory } from "@/lib/taskmark/parse-items"
+import {
+  collectCompletedLeafPointSamples,
+  collectMetricLeaves,
+  computeProjectStatusMetrics,
+} from "@/lib/taskmark/project-metrics"
+import {
+  type BoardSnapshot,
+  storyKey,
+} from "@/lib/taskmark/snapshot-types"
+import type { DiscoveredProject } from "@/lib/taskmark/types"
+import { loadWorkspace } from "@/lib/taskmark/workspace"
+import { asString, extractFrontmatter } from "@/lib/taskmark/frontmatter"
+
+function toRef(
+  meta: { id: string; title: string; type: string },
+  filePath: string
+): WorkItemRef {
+  const type = meta.type.toLowerCase()
+  if (type === "epic") {
+    return { kind: "epic", id: meta.id, title: meta.title, filePath }
+  }
+  if (type === "story") {
+    return { kind: "story", id: meta.id, title: meta.title, filePath }
+  }
+  const itemType = type === "bug" ? "bug" : "task"
+  return {
+    kind: "item",
+    id: meta.id,
+    title: meta.title,
+    filePath,
+    itemType,
+  }
+}
+
+function readMeta(
+  filePath: string
+): { id: string; title: string; type: string } | null {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8")
+    const fm = extractFrontmatter(raw)
+    if (!fm) return null
+    const id = asString(fm.id)
+    const title = asString(fm.title)
+    if (!id) return null
+    return { id, title, type: asString(fm.type).toLowerCase() }
+  } catch {
+    return null
+  }
+}
+
+/** Walk one board and collect every work-item ref. */
+export function listAllWorkItemRefs(boardPath: string): WorkItemRef[] {
+  const refs: WorkItemRef[] = []
+  const epicsDir = path.join(boardPath, "epics")
+  let epicEntries: fs.Dirent[]
+  try {
+    epicEntries = fs.readdirSync(epicsDir, { withFileTypes: true })
+  } catch {
+    return refs
+  }
+
+  for (const epicEntry of epicEntries) {
+    if (!epicEntry.isDirectory() || epicEntry.name.startsWith(".")) continue
+    const epicDir = path.join(epicsDir, epicEntry.name)
+
+    const epicFile = path.join(epicDir, "epic.md")
+    if (fs.existsSync(epicFile)) {
+      const meta = readMeta(epicFile)
+      if (meta) refs.push(toRef(meta, epicFile))
+    }
+
+    const epicItemsDir = path.join(epicDir, "items")
+    try {
+      for (const name of fs.readdirSync(epicItemsDir)) {
+        if (!name.endsWith(".md") || name.startsWith(".")) continue
+        const filePath = path.join(epicItemsDir, name)
+        const meta = readMeta(filePath)
+        if (meta) refs.push(toRef(meta, filePath))
+      }
+    } catch {
+      /* no epic-direct items */
+    }
+
+    const storiesDir = path.join(epicDir, "stories")
+    let storyEntries: fs.Dirent[]
+    try {
+      storyEntries = fs.readdirSync(storiesDir, { withFileTypes: true })
+    } catch {
+      continue
+    }
+
+    for (const storyEntry of storyEntries) {
+      if (!storyEntry.isDirectory() || storyEntry.name.startsWith(".")) continue
+      const storyDir = path.join(storiesDir, storyEntry.name)
+      const storyFile = path.join(storyDir, "story.md")
+      if (fs.existsSync(storyFile)) {
+        const meta = readMeta(storyFile)
+        if (meta) refs.push(toRef(meta, storyFile))
+      }
+
+      const storyItemsDir = path.join(storyDir, "items")
+      try {
+        for (const name of fs.readdirSync(storyItemsDir)) {
+          if (!name.endsWith(".md") || name.startsWith(".")) continue
+          const filePath = path.join(storyItemsDir, name)
+          const meta = readMeta(filePath)
+          if (meta) refs.push(toRef(meta, filePath))
+        }
+      } catch {
+        /* no story items */
+      }
+    }
+  }
+
+  return refs
+}
+
+export function buildBoardSnapshot(
+  projects: DiscoveredProject[],
+  active: DiscoveredProject
+): BoardSnapshot {
+  const epics = parseEpicsForProject(active)
+  const workItemsByEpic: BoardSnapshot["workItemsByEpic"] = {}
+  const itemsByStory: BoardSnapshot["itemsByStory"] = {}
+
+  for (const epic of epics.epics) {
+    const epicList = parseWorkItemsForEpic(active, epic.id, epic.title)
+    workItemsByEpic[epic.id] = epicList
+    for (const row of epicList.rows) {
+      if (row.kind !== "story") continue
+      itemsByStory[storyKey(epic.id, row.id)] = parseItemsForStory(
+        active,
+        epic.id,
+        row.id
+      )
+    }
+  }
+
+  const refs = listAllWorkItemRefs(active.boardPath)
+  const refsById: BoardSnapshot["refsById"] = {}
+  const detailsByPath: BoardSnapshot["detailsByPath"] = {}
+
+  for (const ref of refs) {
+    refsById[ref.id] = ref
+    const hint =
+      ref.kind === "epic" ? "epic" : ref.kind === "story" ? "story" : "item"
+    const detail = loadWorkItemDetailSync(projects, ref.filePath, hint)
+    if (detail.ok) {
+      detailsByPath[ref.filePath] = detail.detail
+    }
+  }
+
+  const hideCompletedDefaults = {
+    epics: false,
+    stories: false,
+    tasks: false,
+    overallWorkItems: false,
+    workItems: false,
+  } as const
+
+  return {
+    version: 1,
+    builtAt: new Date().toISOString(),
+    project: active,
+    projects,
+    epics,
+    workItemsView: parseWorkItemsViewForProject(active),
+    workItemsByEpic,
+    itemsByStory,
+    statusMetrics: computeProjectStatusMetrics(active),
+    countableCompletions: collectCompletedLeafPointSamples(
+      collectMetricLeaves(active)
+    ),
+    hideCompletedDefaults: { ...hideCompletedDefaults },
+    detailsByPath,
+    refsById,
+  }
+}
+
+/** Build snapshot from env/cwd autoconfig (no cookies). */
+export function buildBoardSnapshotFromEnv(): BoardSnapshot {
+  const workspace = loadWorkspace([])
+  if (workspace.projects.length === 0) {
+    throw new Error(
+      "No Taskmark board found. Set TASKMARK_BOARD or run from a board / product root."
+    )
+  }
+  const active = workspace.projects[0]!
+  return buildBoardSnapshot(workspace.projects, active)
+}

package/dist/standalone/lib/taskmark/cookies.ts

@@ -11,8 +11,10 @@ import {
   type HideCompletedCookieKey,
 } from "@/lib/taskmark/constants"
 import { parseHideCompletedCookieValue } from "@/lib/taskmark/hide-completed-cookie"
+import { isStaticRuntime } from "@/lib/taskmark/static-mode"
 
 async function readEncodedCookie(name: string): Promise<string | null> {
+  if (isStaticRuntime()) return null
   const store = await cookies()
   const value = store.get(name)?.value
   if (!value) return null
@@ -56,6 +58,7 @@ export async function getMasterFoldersCookie(): Promise<string[]> {
 }
 
 export async function setMasterFoldersCookie(masters: string[]): Promise<void> {
+  if (isStaticRuntime()) return
   const unique = [
     ...new Set(masters.map((m) => m.trim()).filter(Boolean)),
   ]
@@ -90,6 +93,7 @@ export async function addMasterFolderCookie(masterPath: string): Promise<string[
 }
 
 export async function clearMasterFoldersCookie(): Promise<void> {
+  if (isStaticRuntime()) return
   const store = await cookies()
   store.delete(MASTER_FOLDERS_COOKIE)
   store.delete(MASTER_FOLDER_COOKIE)
@@ -106,6 +110,7 @@ export async function getActiveProjectCookie(): Promise<string | null> {
 }
 
 export async function setActiveProjectCookie(projectId: string): Promise<void> {
+  if (isStaticRuntime()) return
   const store = await cookies()
   store.set(ACTIVE_PROJECT_COOKIE, encodeCookieValue(projectId), {
     path: "/",
@@ -116,6 +121,7 @@ export async function setActiveProjectCookie(projectId: string): Promise<void> {
 }
 
 export async function clearActiveProjectCookie(): Promise<void> {
+  if (isStaticRuntime()) return
   const store = await cookies()
   store.delete(ACTIVE_PROJECT_COOKIE)
 }
@@ -123,6 +129,7 @@ export async function clearActiveProjectCookie(): Promise<void> {
 export async function getHideCompletedCookie(
   key: HideCompletedCookieKey
 ): Promise<boolean> {
+  if (isStaticRuntime()) return false
   const store = await cookies()
   return parseHideCompletedCookieValue(
     store.get(HIDE_COMPLETED_COOKIES[key])?.value
@@ -132,6 +139,15 @@ export async function getHideCompletedCookie(
 export async function getHideCompletedCookies(): Promise<
   Record<HideCompletedCookieKey, boolean>
 > {
+  if (isStaticRuntime()) {
+    return {
+      epics: false,
+      stories: false,
+      tasks: false,
+      overallWorkItems: false,
+      workItems: false,
+    }
+  }
   const store = await cookies()
   return {
     epics: parseHideCompletedCookieValue(

package/dist/standalone/{dist/standalone/dist/standalone/dist/standalone/app/board/actions.ts → lib/taskmark/detail-load.ts}

@@ -1,16 +1,14 @@
-"use server"
-
+/**
+ * Shared board detail loading (used by server actions and static snapshot).
+ */
 import fs from "node:fs"
 import path from "node:path"
 
-import { getActiveProjectCookie, getMasterFoldersCookie } from "@/lib/taskmark/cookies"
-import { resolveActiveProject } from "@/lib/taskmark/active-project"
 import { parseWorkItemDetailFromRaw } from "@/lib/taskmark/parse-detail"
 import type {
   DetailChildItem,
   WorkItemDetail,
   WorkItemDetailResult,
-  WorkItemRef,
 } from "@/lib/taskmark/detail-types"
 import { parseItemsForEpic, parseItemsForStory } from "@/lib/taskmark/parse-items"
 import { parseStoriesForEpic } from "@/lib/taskmark/parse-stories"
@@ -19,14 +17,14 @@ import {
   findWorkItemInProjects,
   findWorkItemOnBoard,
 } from "@/lib/taskmark/resolve-work-item"
-import { loadConfiguredWorkspace } from "@/lib/taskmark/workspace"
+import type { WorkItemRef } from "@/lib/taskmark/detail-types"
 
 function isPathInside(parent: string, child: string): boolean {
   const rel = path.relative(parent, child)
   return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel))
 }
 
-function findProjectForFile(
+export function findProjectForFile(
   projects: DiscoveredProject[],
   filePath: string
 ): DiscoveredProject | null {
@@ -37,7 +35,7 @@ function findProjectForFile(
   )
 }
 
-function attachChildren(
+export function attachChildren(
   detail: WorkItemDetail,
   project: DiscoveredProject
 ): WorkItemDetail {
@@ -89,35 +87,64 @@ function attachChildren(
   return detail
 }
 
-export type ResolveWorkItemResult =
-  | { ok: true; ref: WorkItemRef }
-  | { ok: false; itemId: string; message: string }
+export function loadWorkItemDetailSync(
+  projects: DiscoveredProject[],
+  filePath: string,
+  hint?: "epic" | "story" | "item"
+): WorkItemDetailResult {
+  if (!filePath || typeof filePath !== "string") {
+    return { ok: false, filePath: filePath ?? "", message: "Missing file path" }
+  }
 
-/**
- * Resolve a shareable work item id (E-/S-/T-/B-) to a WorkItemRef.
- *
- * - `withinFilePath`: only search the board that contains that file (in-sheet nav).
- * - otherwise: only search the **active** project board (shared `?item=` links).
- */
-export async function resolveWorkItemById(
+  const resolved = path.resolve(filePath)
+  if (!resolved.endsWith(".md")) {
+    return { ok: false, filePath: resolved, message: "Not a markdown file" }
+  }
+
+  const project = findProjectForFile(projects, resolved)
+  if (!project) {
+    return {
+      ok: false,
+      filePath: resolved,
+      message: "File is outside configured Taskmark boards",
+    }
+  }
+
+  let raw: string
+  try {
+    raw = fs.readFileSync(resolved, "utf8")
+  } catch (err) {
+    return {
+      ok: false,
+      filePath: resolved,
+      message: err instanceof Error ? err.message : "Failed to read file",
+    }
+  }
+
+  const result = parseWorkItemDetailFromRaw(raw, resolved, hint)
+  if (!result.ok) return result
+
+  return { ok: true, detail: attachChildren(result.detail, project) }
+}
+
+export function resolveWorkItemByIdSync(
+  projects: DiscoveredProject[],
   itemId: string,
-  options?: { withinFilePath?: string | null }
-): Promise<ResolveWorkItemResult> {
+  options?: {
+    withinFilePath?: string | null
+    activeBoardPath?: string | null
+  }
+):
+  | { ok: true; ref: WorkItemRef }
+  | { ok: false; itemId: string; message: string } {
   const id = typeof itemId === "string" ? itemId.trim() : ""
   if (!id) {
     return { ok: false, itemId: "", message: "Missing work item id" }
   }
 
-  const masters = await getMasterFoldersCookie()
-  if (masters.length === 0) {
-    return { ok: false, itemId: id, message: "No workspace configured" }
-  }
-
-  const workspace = loadConfiguredWorkspace(masters)
   const within = options?.withinFilePath?.trim() || null
-
   if (within) {
-    const project = findProjectForFile(workspace.projects, within)
+    const project = findProjectForFile(projects, within)
     if (!project) {
       return {
         ok: false,
@@ -136,18 +163,9 @@ export async function resolveWorkItemById(
     return { ok: true, ref }
   }
 
-  const savedActiveId = await getActiveProjectCookie()
-  const active = resolveActiveProject(workspace.projects, savedActiveId)
-  if (!active) {
-    return {
-      ok: false,
-      itemId: id,
-      message: "No active Taskmark project selected",
-    }
-  }
-
-  const resolved = findWorkItemInProjects(workspace.projects, id, {
-    boardPath: active.boardPath,
+  const boardPath = options?.activeBoardPath?.trim() || null
+  const resolved = findWorkItemInProjects(projects, id, {
+    boardPath: boardPath ?? undefined,
   })
   if (!resolved) {
     return {
@@ -157,55 +175,6 @@ export async function resolveWorkItemById(
     }
   }
 
-  const { boardPath: _boardPath, projectId: _projectId, ...ref } = resolved
+  const { boardPath: _b, projectId: _p, ...ref } = resolved
   return { ok: true, ref }
 }
-
-/**
- * Load and parse a full work item detail from an absolute markdown path.
- * Path must resolve under a configured project's boardPath.
- */
-export async function loadWorkItemDetail(
-  filePath: string,
-  hint?: "epic" | "story" | "item"
-): Promise<WorkItemDetailResult> {
-  if (!filePath || typeof filePath !== "string") {
-    return { ok: false, filePath: filePath ?? "", message: "Missing file path" }
-  }
-
-  const resolved = path.resolve(filePath)
-  if (!resolved.endsWith(".md")) {
-    return { ok: false, filePath: resolved, message: "Not a markdown file" }
-  }
-
-  const masters = await getMasterFoldersCookie()
-  if (masters.length === 0) {
-    return { ok: false, filePath: resolved, message: "No workspace configured" }
-  }
-
-  const workspace = loadConfiguredWorkspace(masters)
-  const project = findProjectForFile(workspace.projects, resolved)
-  if (!project) {
-    return {
-      ok: false,
-      filePath: resolved,
-      message: "File is outside configured Taskmark boards",
-    }
-  }
-
-  let raw: string
-  try {
-    raw = fs.readFileSync(resolved, "utf8")
-  } catch (err) {
-    return {
-      ok: false,
-      filePath: resolved,
-      message: err instanceof Error ? err.message : "Failed to read file",
-    }
-  }
-
-  const result = parseWorkItemDetailFromRaw(raw, resolved, hint)
-  if (!result.ok) return result
-
-  return { ok: true, detail: attachChildren(result.detail, project) }
-}

package/dist/standalone/lib/taskmark/load-snapshot-server.ts

@@ -0,0 +1,11 @@
+import "server-only"
+import fs from "node:fs"
+import path from "node:path"
+
+import type { BoardSnapshot } from "@/lib/taskmark/snapshot-types"
+
+export function loadSnapshotFromPublic(): BoardSnapshot {
+  const file = path.join(process.cwd(), "public", "taskmark-snapshot.json")
+  const raw = fs.readFileSync(file, "utf8")
+  return JSON.parse(raw) as BoardSnapshot
+}

package/dist/standalone/lib/taskmark/project-metrics-shared.ts

@@ -0,0 +1,21 @@
+import type { ContributorIdentity } from "@/lib/taskmark/identity"
+
+/** Shared metrics shape — safe for client components (no fs). */
+export type ProjectStatusMetrics = {
+  totalWorkItems: number
+  completeWorkItems: number
+  /** Story points completed in the current ISO week from done task/bug leaves. */
+  currentWeekPointsDone: number
+  /** Average story points completed per ISO week over the 90-day window; null if no done tasks/bugs. */
+  currentSpeedPtsPerWeek: number | null
+  /** Weeks included in the speed average (0 when no speed). */
+  speedWeekCount: number
+  contributors: ContributorIdentity[]
+}
+
+/** Format average pts/week for display (one decimal when needed). */
+export function formatSpeedPtsPerWeek(value: number | null): string {
+  if (value == null || !Number.isFinite(value)) return "—"
+  const rounded = Math.round(value * 10) / 10
+  return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1)
+}

package/dist/standalone/lib/taskmark/project-metrics.ts

@@ -18,6 +18,12 @@ import {
   type SolvedCompletionSample,
 } from "@/lib/taskmark/timeframe-filters"
 
+export type {
+  ProjectStatusMetrics,
+} from "@/lib/taskmark/project-metrics-shared"
+export { formatSpeedPtsPerWeek } from "@/lib/taskmark/project-metrics-shared"
+import type { ProjectStatusMetrics } from "@/lib/taskmark/project-metrics-shared"
+
 export type MetricLeafKind = "epic" | "story" | "task" | "bug"
 
 export type MetricLeaf = {
@@ -30,18 +36,6 @@ export type MetricLeaf = {
   resolvers: ContributorIdentity[]
 }
 
-export type ProjectStatusMetrics = {
-  totalWorkItems: number
-  completeWorkItems: number
-  /** Story points completed in the current ISO week from done task/bug leaves. */
-  currentWeekPointsDone: number
-  /** Average story points completed per ISO week over the 90-day window; null if no done tasks/bugs. */
-  currentSpeedPtsPerWeek: number | null
-  /** Weeks included in the speed average (0 when no speed). */
-  speedWeekCount: number
-  contributors: ContributorIdentity[]
-}
-
 const COUNTABLE_KINDS = new Set<MetricLeafKind>(["story", "task", "bug"])
 
 function emailKey(email: string, name: string): string {
@@ -288,9 +282,3 @@ export function computeProjectStatusMetrics(
   }
 }
 
-/** Format average pts/week for display (one decimal when needed). */
-export function formatSpeedPtsPerWeek(value: number | null): string {
-  if (value == null || !Number.isFinite(value)) return "—"
-  const rounded = Math.round(value * 10) / 10
-  return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1)
-}

package/dist/standalone/lib/taskmark/snapshot-client.ts

@@ -0,0 +1,67 @@
+"use client"
+
+import * as React from "react"
+
+import type { WorkItemDetail, WorkItemDetailResult, WorkItemRef } from "@/lib/taskmark/detail-types"
+import {
+  SNAPSHOT_PATH,
+  type BoardSnapshot,
+} from "@/lib/taskmark/snapshot-types"
+
+let cached: BoardSnapshot | null = null
+let inflight: Promise<BoardSnapshot> | null = null
+
+export async function getBoardSnapshot(): Promise<BoardSnapshot> {
+  if (cached) return cached
+  if (!inflight) {
+    inflight = fetch(SNAPSHOT_PATH)
+      .then((r) => {
+        if (!r.ok) throw new Error(`Failed to load ${SNAPSHOT_PATH}`)
+        return r.json() as Promise<BoardSnapshot>
+      })
+      .then((snap) => {
+        cached = snap
+        return snap
+      })
+      .finally(() => {
+        inflight = null
+      })
+  }
+  return inflight
+}
+
+export function seedBoardSnapshot(snapshot: BoardSnapshot): void {
+  cached = snapshot
+}
+
+export async function loadWorkItemDetailFromSnapshot(
+  filePath: string
+): Promise<WorkItemDetailResult> {
+  const snap = await getBoardSnapshot()
+  const detail = snap.detailsByPath[filePath]
+  if (!detail) {
+    return {
+      ok: false,
+      filePath,
+      message: "Work item detail not found in static snapshot",
+    }
+  }
+  return { ok: true, detail }
+}
+
+export async function resolveWorkItemByIdFromSnapshot(
+  itemId: string
+): Promise<
+  | { ok: true; ref: WorkItemRef }
+  | { ok: false; itemId: string; message: string }
+> {
+  const id = itemId.trim()
+  const snap = await getBoardSnapshot()
+  const ref = snap.refsById[id]
+  if (!ref) {
+    return { ok: false, itemId: id, message: `Work item ${id} was not found` }
+  }
+  return { ok: true, ref }
+}
+
+export type { WorkItemDetail }

package/dist/standalone/lib/taskmark/snapshot-types.ts

@@ -0,0 +1,37 @@
+import type { HideCompletedCookieKey } from "@/lib/taskmark/constants"
+import type { WorkItemDetail, WorkItemRef } from "@/lib/taskmark/detail-types"
+import type { ProjectEpicList } from "@/lib/taskmark/epic-types"
+import type {
+  EpicWorkItemsList,
+  WorkItemsViewList,
+} from "@/lib/taskmark/flat-work-item-types"
+import type { StoryItemList } from "@/lib/taskmark/item-types"
+import type { ProjectStatusMetrics } from "@/lib/taskmark/project-metrics-shared"
+import type { SolvedCompletionSample } from "@/lib/taskmark/timeframe-filters"
+import type { DiscoveredProject } from "@/lib/taskmark/types"
+
+export const SNAPSHOT_PATH = "/taskmark-snapshot.json"
+
+export type BoardSnapshot = {
+  version: 1
+  builtAt: string
+  project: DiscoveredProject
+  projects: DiscoveredProject[]
+  epics: ProjectEpicList
+  workItemsView: WorkItemsViewList
+  /** Epic id → overall work-items list for that epic */
+  workItemsByEpic: Record<string, EpicWorkItemsList>
+  /** `${epicId}::${storyId}` → sub-task list */
+  itemsByStory: Record<string, StoryItemList>
+  statusMetrics: ProjectStatusMetrics
+  countableCompletions: SolvedCompletionSample[]
+  hideCompletedDefaults: Record<HideCompletedCookieKey, boolean>
+  /** Absolute file path → detail (children attached) */
+  detailsByPath: Record<string, WorkItemDetail>
+  /** Work item id → ref for sheet open-by-id */
+  refsById: Record<string, WorkItemRef>
+}
+
+export function storyKey(epicId: string, storyId: string): string {
+  return `${epicId}::${storyId}`
+}

package/dist/standalone/lib/taskmark/static-mode.ts

@@ -0,0 +1,15 @@
+/**
+ * Static hosting mode (Vercel / `taskmark build`).
+ * Build: TASKMARK_STATIC=1
+ * Runtime (client + baked HTML): NEXT_PUBLIC_TASKMARK_STATIC=1
+ */
+export function isStaticBuild(): boolean {
+  return process.env.TASKMARK_STATIC === "1"
+}
+
+export function isStaticRuntime(): boolean {
+  return (
+    process.env.NEXT_PUBLIC_TASKMARK_STATIC === "1" ||
+    process.env.TASKMARK_STATIC === "1"
+  )
+}

package/dist/standalone/next.config.ts

@@ -1,8 +1,19 @@
 import type { NextConfig } from "next"
 
+const staticExport = process.env.TASKMARK_STATIC === "1"
+
 const nextConfig: NextConfig = {
-  // Ship a relocatable Node server for `npx taskmark serve` (see bin/ + scripts/).
-  output: "standalone",
+  // `taskmark serve` uses standalone; `taskmark build` (static hosting) uses export.
+  output: staticExport ? "export" : "standalone",
+  images: staticExport ? { unoptimized: true } : undefined,
+  // Static build stubs server actions; skip tsc against those temporary stubs.
+  typescript: staticExport ? { ignoreBuildErrors: true } : undefined,
+  // Avoid tracing prior dist/standalone into itself (nested copies).
+  outputFileTracingExcludes: staticExport
+    ? undefined
+    : {
+        "*": ["./dist/**/*", "./out/**/*"],
+      },
 }
 
 export default nextConfig