@knotpad/app 0.1.0 → 0.1.2

package/lib/sync-worker.ts

@@ -1,388 +0,0 @@
-/**
- * Cloud sync worker — server-side only.
- *
- * Runs every 5 minutes via cron (or on demand via POST /api/sync/trigger).
- * Pulls cloud changes, pulls local changes, resolves conflicts, pushes back.
- *
- * Strategy per entity type:
- *  - Task status/assignment → last-write-wins (timestamp)
- *  - New tasks on both sides → union merge (keep all)
- *  - Note content → three-way merge (paragraph level, stored base snapshot)
- *  - Deletes → tombstone pattern (check before insert, write on delete)
- */
-
-import { prisma, getCloudPrisma } from "@/lib/prisma";
-import {
-  lastWriteWins,
-  threeWayMerge,
-  isTombstoned,
-  logConflict,
-} from "@/lib/conflict-resolver";
-import {
-  getOrCreateSyncState,
-  getSnapshots,
-  saveSnapshots,
-  saveSnapshot,
-} from "@/lib/note-sync";
-import { encryptForSync, decryptFromSync } from "@/lib/note-crypto";
-import { isWorkspacePro, isWorkspaceCloud } from "@/lib/license";
-
-// In-process guard so the cron run and an on-demand /api/sync/trigger can't
-// process the same workspace concurrently (which would race cloud writes and
-// throw on duplicate-id inserts). Per-instance; a DB-backed lock would be
-// needed for multi-instance deployments.
-const inFlight = new Set<string>();
-
-export type SyncStatus =
-  | "synced"
-  | "syncing"
-  | "conflict"
-  | "offline"
-  | "lapsed"
-  | "error";
-
-export type SyncResult = {
-  status: SyncStatus;
-  notesProcessed: number;
-  tasksProcessed: number;
-  conflictsFound: number;
-  error?: string;
-};
-
-export async function runSync(workspaceId: string): Promise<SyncResult> {
-  const workspace = await prisma.workspace.findUnique({
-    where: { id: workspaceId },
-    include: { syncState: true },
-  });
-
-  if (!workspace) {
-    return { status: "error", notesProcessed: 0, tasksProcessed: 0, conflictsFound: 0, error: "Workspace not found" };
-  }
-
-  if (!isWorkspacePro(workspace) || !isWorkspaceCloud(workspace)) {
-    return { status: "synced", notesProcessed: 0, tasksProcessed: 0, conflictsFound: 0 };
-  }
-
-  const cloudPrisma = getCloudPrisma();
-  if (!cloudPrisma) {
-    return { status: "error", notesProcessed: 0, tasksProcessed: 0, conflictsFound: 0, error: "CLOUD_DATABASE_URL is not configured" };
-  }
-
-  // Refuse to run two syncs for the same workspace at once.
-  if (inFlight.has(workspaceId)) {
-    return { status: "syncing", notesProcessed: 0, tasksProcessed: 0, conflictsFound: 0 };
-  }
-  inFlight.add(workspaceId);
-
-  // Capture the cutoff BEFORE fetching so edits that land mid-run aren't skipped
-  // next time (they'll have updatedAt >= syncStart and get reprocessed).
-  const syncStart = new Date();
-
-  try {
-  const syncState = await getOrCreateSyncState(workspaceId);
-  const lastSyncedAt = syncState.lastSyncedAt ?? new Date(0);
-  const { snapshots, version: snapshotVersion } = await getSnapshots(workspaceId);
-
-  let notesProcessed = 0;
-  let tasksProcessed = 0;
-  let conflictsFound = 0;
-
-  // ── Notes sync ──────────────────────────────────────────────────────────────
-
-  const [localNotes, cloudNotes] = await Promise.all([
-    prisma.note.findMany({ where: { workspaceId }, orderBy: { updatedAt: "asc" } }),
-    cloudPrisma.note.findMany({ where: { workspaceId }, orderBy: { updatedAt: "asc" } }),
-  ]);
-
-  const localNoteMap = new Map(localNotes.map((n) => [n.id, n]));
-  const cloudNoteMap = new Map(cloudNotes.map((n) => [n.id, n]));
-
-  // Notes that changed locally since last sync
-  const localChanged = localNotes.filter((n) => n.updatedAt > lastSyncedAt);
-  // Notes that changed in the cloud since last sync
-  const cloudChanged = cloudNotes.filter((n) => n.updatedAt > lastSyncedAt);
-  const cloudChangedIds = new Set(cloudChanged.map((n) => n.id));
-
-  for (const localNote of localChanged) {
-    if (await isTombstoned(workspaceId, "note", localNote.id)) continue;
-
-    const cloudNote = cloudNoteMap.get(localNote.id);
-
-    // Note content is encrypted symmetrically (same pepper + workspace salt) so
-    // ciphertext is portable between DBs as-is; only the merge needs plaintext.
-    if (!cloudNote) {
-      // New locally — push to cloud (upsert: tolerate a racing prior insert)
-      await cloudPrisma.note.upsert({
-        where: { id: localNote.id },
-        create: {
-          id: localNote.id,
-          workspaceId: localNote.workspaceId,
-          title: localNote.title,
-          content: localNote.content,
-          version: localNote.version,
-          deviceId: localNote.deviceId,
-          createdAt: localNote.createdAt,
-          updatedAt: localNote.updatedAt,
-        },
-        update: {
-          title: localNote.title,
-          content: localNote.content,
-          version: localNote.version,
-          updatedAt: localNote.updatedAt,
-        },
-      });
-      snapshots[localNote.id] = await decryptFromSync(localNote.content, workspaceId);
-      notesProcessed++;
-      continue;
-    }
-
-    if (!cloudChangedIds.has(localNote.id)) {
-      // Only local changed — push update to cloud
-      await cloudPrisma.note.update({
-        where: { id: localNote.id },
-        data: {
-          title: localNote.title,
-          content: localNote.content,
-          version: localNote.version,
-          updatedAt: localNote.updatedAt,
-        },
-      });
-      snapshots[localNote.id] = await decryptFromSync(localNote.content, workspaceId);
-      notesProcessed++;
-      continue;
-    }
-
-    // Both changed — three-way merge on plaintext, then re-encrypt for storage.
-    const base = snapshots[localNote.id] ?? "";
-    const localPlain = await decryptFromSync(localNote.content, workspaceId);
-    const cloudPlain = await decryptFromSync(cloudNote.content, workspaceId);
-    const result = threeWayMerge(base, localPlain, cloudPlain);
-
-    if (!result.hasConflicts) {
-      const nextVersion = Math.max(localNote.version, cloudNote.version) + 1;
-      const mergedCipher = await encryptForSync(result.merged, workspaceId);
-      await Promise.all([
-        prisma.note.update({
-          where: { id: localNote.id },
-          data: { content: mergedCipher, version: nextVersion },
-        }),
-        cloudPrisma.note.update({
-          where: { id: localNote.id },
-          data: { content: mergedCipher, version: nextVersion, updatedAt: new Date() },
-        }),
-      ]);
-      snapshots[localNote.id] = result.merged;
-    } else {
-      // Store ciphertext in the conflict log; the conflicts API decrypts for display.
-      await logConflict(workspaceId, "note", localNote.id, localNote.content, cloudNote.content);
-      conflictsFound++;
-    }
-    notesProcessed++;
-  }
-
-  // Notes new in cloud — pull down to local
-  for (const cloudNote of cloudChanged) {
-    if (localNoteMap.has(cloudNote.id)) continue; // already handled above
-    if (await isTombstoned(workspaceId, "note", cloudNote.id)) continue;
-
-    await prisma.note.upsert({
-      where: { id: cloudNote.id },
-      create: {
-        id: cloudNote.id,
-        workspaceId: cloudNote.workspaceId,
-        title: cloudNote.title,
-        content: cloudNote.content,
-        version: cloudNote.version,
-        deviceId: cloudNote.deviceId,
-        createdAt: cloudNote.createdAt,
-        updatedAt: cloudNote.updatedAt,
-      },
-      update: {
-        title: cloudNote.title,
-        content: cloudNote.content,
-        version: cloudNote.version,
-        updatedAt: cloudNote.updatedAt,
-      },
-    });
-    snapshots[cloudNote.id] = await decryptFromSync(cloudNote.content, workspaceId);
-    notesProcessed++;
-  }
-
-  // ── Tasks sync ───────────────────────────────────────────────────────────────
-
-  const [localTasks, cloudTasks] = await Promise.all([
-    prisma.task.findMany({ where: { workspaceId, updatedAt: { gt: lastSyncedAt } } }),
-    cloudPrisma.task.findMany({ where: { workspaceId, updatedAt: { gt: lastSyncedAt } } }),
-  ]);
-
-  const localTaskMap = new Map(localTasks.map((t) => [t.id, t]));
-  const cloudTaskMap = new Map(cloudTasks.map((t) => [t.id, t]));
-
-  // Push locally changed tasks to cloud
-  for (const localTask of localTasks) {
-    if (await isTombstoned(workspaceId, "task", localTask.id)) continue;
-
-    const cloudTask = cloudTaskMap.get(localTask.id);
-
-    if (!cloudTask) {
-      await cloudPrisma.task.upsert({
-        where: { id: localTask.id },
-        create: {
-          id: localTask.id,
-          workspaceId: localTask.workspaceId,
-          noteId: localTask.noteId,
-          title: localTask.title,
-          status: localTask.status,
-          assigneeType: localTask.assigneeType,
-          assigneeId: localTask.assigneeId,
-          fileRefs: localTask.fileRefs,
-          version: localTask.version,
-          createdAt: localTask.createdAt,
-          updatedAt: localTask.updatedAt,
-        },
-        update: {
-          status: localTask.status,
-          version: localTask.version,
-          updatedAt: localTask.updatedAt,
-        },
-      });
-      tasksProcessed++;
-      continue;
-    }
-
-    const winner = lastWriteWins(
-      { id: localTask.id, updatedAt: localTask.updatedAt, version: localTask.version },
-      { id: cloudTask.id, updatedAt: cloudTask.updatedAt, version: cloudTask.version }
-    );
-
-    if (winner === "local") {
-      await cloudPrisma.task.update({
-        where: { id: localTask.id },
-        data: { status: localTask.status, version: localTask.version, updatedAt: localTask.updatedAt },
-      });
-    } else {
-      await prisma.task.update({
-        where: { id: localTask.id },
-        data: { status: cloudTask.status, version: cloudTask.version },
-      });
-    }
-    tasksProcessed++;
-  }
-
-  // Pull tasks new in cloud that don't exist locally
-  for (const cloudTask of cloudTasks) {
-    if (localTaskMap.has(cloudTask.id)) continue;
-    if (await isTombstoned(workspaceId, "task", cloudTask.id)) continue;
-
-    await prisma.task.upsert({
-      where: { id: cloudTask.id },
-      create: {
-        id: cloudTask.id,
-        workspaceId: cloudTask.workspaceId,
-        noteId: cloudTask.noteId,
-        title: cloudTask.title,
-        status: cloudTask.status,
-        assigneeType: cloudTask.assigneeType,
-        assigneeId: cloudTask.assigneeId,
-        fileRefs: cloudTask.fileRefs,
-        version: cloudTask.version,
-        createdAt: cloudTask.createdAt,
-        updatedAt: cloudTask.updatedAt,
-      },
-      update: {
-        status: cloudTask.status,
-        version: cloudTask.version,
-        updatedAt: cloudTask.updatedAt,
-      },
-    });
-    tasksProcessed++;
-  }
-
-  // ── Finalize ─────────────────────────────────────────────────────────────────
-
-  await saveSnapshots(workspaceId, snapshots, snapshotVersion);
-  await prisma.syncState.update({
-    where: { workspaceId },
-    data: {
-      // Use the pre-fetch cutoff so writes during the run are picked up next time.
-      lastSyncedAt: syncStart,
-      localVersion: { increment: 1 },
-      cloudVersion: { increment: 1 },
-    },
-  });
-
-  const status: SyncStatus = conflictsFound > 0 ? "conflict" : "synced";
-  return { status, notesProcessed, tasksProcessed, conflictsFound };
-  } finally {
-    inFlight.delete(workspaceId);
-  }
-}
-
-// ── Per-device helpers (called by devices pushing a single change) ────────────
-
-export async function syncNoteConflict(
-  workspaceId: string,
-  noteId: string,
-  incomingContent: string,
-  incomingDeviceId: string
-): Promise<{ autoResolved: boolean; conflictId?: string }> {
-  const note = await prisma.note.findUnique({ where: { id: noteId } });
-  if (!note) return { autoResolved: false };
-
-  if (await isTombstoned(workspaceId, "note", noteId)) {
-    return { autoResolved: true };
-  }
-
-  const { snapshots } = await getSnapshots(workspaceId);
-  const base = snapshots[noteId] ?? "";
-
-  // incomingContent is plaintext from the pushing device; note.content is ciphertext.
-  const currentPlain = await decryptFromSync(note.content, workspaceId);
-  if (incomingContent === currentPlain) {
-    return { autoResolved: true };
-  }
-
-  const result = threeWayMerge(base, currentPlain, incomingContent);
-
-  if (!result.hasConflicts) {
-    const mergedCipher = await encryptForSync(result.merged, workspaceId);
-    await prisma.note.update({
-      where: { id: noteId },
-      data: { content: mergedCipher, version: { increment: 1 }, deviceId: incomingDeviceId },
-    });
-    await saveSnapshot(workspaceId, noteId, result.merged);
-    return { autoResolved: true };
-  }
-
-  // Log ciphertext for both sides (conflicts API decrypts for display).
-  const incomingCipher = await encryptForSync(incomingContent, workspaceId);
-  const conflictId = await logConflict(workspaceId, "note", noteId, note.content, incomingCipher);
-  return { autoResolved: false, conflictId };
-}
-
-export async function syncTaskUpdate(
-  workspaceId: string,
-  taskId: string,
-  incomingStatus: string,
-  incomingUpdatedAt: Date
-): Promise<"applied" | "rejected" | "tombstoned"> {
-  if (await isTombstoned(workspaceId, "task", taskId)) return "tombstoned";
-
-  const task = await prisma.task.findUnique({ where: { id: taskId } });
-  if (!task) return "rejected";
-
-  const winner = lastWriteWins(
-    { id: task.id, updatedAt: task.updatedAt, version: task.version },
-    { id: taskId, updatedAt: incomingUpdatedAt, version: task.version }
-  );
-
-  if (winner === "cloud") {
-    await prisma.task.update({
-      where: { id: taskId },
-      data: { status: incomingStatus as never, version: { increment: 1 } },
-    });
-    return "applied";
-  }
-
-  return "rejected";
-}

package/lib/task-parser.test.ts

@@ -1,91 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseTasksFromMarkdown, isAgentHandle } from "@/lib/task-parser";
-
-describe("parseTasksFromMarkdown", () => {
-  it("parses a basic task with assignee", () => {
-    const [t] = parseTasksFromMarkdown("- [ ] ship docs @alice");
-    expect(t.title).toBe("ship docs");
-    expect(t.assigneeHandle).toBe("@alice");
-    expect(t.isChecked).toBe(false);
-  });
-
-  it("detects checked tasks", () => {
-    const [t] = parseTasksFromMarkdown("- [x] done thing");
-    expect(t.isChecked).toBe(true);
-    expect(t.title).toBe("done thing");
-  });
-
-  it("parses unordered asterisk task items", () => {
-    const [t] = parseTasksFromMarkdown(
-      "* [ ] review spec @bob !medium 2026-06-01..2026-06-05 <spec.md>"
-    );
-
-    expect(t).toEqual(
-      expect.objectContaining({
-        title: "review spec",
-        assigneeHandle: "@bob",
-        isChecked: false,
-        priority: "MEDIUM",
-        startDate: "2026-06-01",
-        dueDate: "2026-06-05",
-        fileRefs: ["spec.md"],
-      })
-    );
-  });
-
-  it("parses ordered task items", () => {
-    const [t] = parseTasksFromMarkdown(
-      "1. [ ] ship release notes @alice !high 2026-06-14..2026-06-20 <notes.md>"
-    );
-
-    expect(t).toEqual(
-      expect.objectContaining({
-        title: "ship release notes",
-        assigneeHandle: "@alice",
-        isChecked: false,
-        priority: "HIGH",
-        startDate: "2026-06-14",
-        dueDate: "2026-06-20",
-        fileRefs: ["notes.md"],
-      })
-    );
-  });
-
-  it("strips refs, mentions, filerefs, and date ranges from the title", () => {
-    const [t] = parseTasksFromMarkdown("- [ ] review [[Spec]] ((Task)) @bob <file.md> 2026-06-01..2026-06-05");
-    expect(t.title).toBe("review");
-    expect(t.startDate).toBe("2026-06-01");
-    expect(t.dueDate).toBe("2026-06-05");
-    expect(t.fileRefs).toEqual(["file.md"]);
-  });
-
-  it("parses checked tasks with priority and dates", () => {
-    const tasks = parseTasksFromMarkdown(
-      "- [x] Ship MCP docs @agent !high 2026-06-14..2026-06-20 <app/mcp/route.tsx>"
-    );
-
-    expect(tasks).toEqual([
-      expect.objectContaining({
-        isChecked: true,
-        priority: "HIGH",
-        startDate: "2026-06-14",
-        dueDate: "2026-06-20",
-      }),
-    ]);
-  });
-
-  it("keeps a lone date as the title when nothing else remains", () => {
-    const [t] = parseTasksFromMarkdown("- [ ] 2026-05-20");
-    expect(t.title).toBe("2026-05-20");
-  });
-
-  it("ignores non-task lines", () => {
-    expect(parseTasksFromMarkdown("# heading\njust text")).toHaveLength(0);
-  });
-
-  it("recognises only @agent as the agent handle", () => {
-    expect(isAgentHandle("@agent")).toBe(true);
-    expect(isAgentHandle("@AGENT")).toBe(true);
-    expect(isAgentHandle("@alice")).toBe(false);
-  });
-});

package/lib/task-parser.ts

@@ -1,81 +0,0 @@
-export type ParsedTask = {
-  title: string;
-  assigneeHandle: string | null;
-  fileRefs: string[];
-  lineIndex: number;
-  isChecked: boolean;
-  startDate: string | null; // ISO date YYYY-MM-DD — start of a date range
-  dueDate: string | null;   // ISO date YYYY-MM-DD — due date or end of range
-  priority: string | null;  // Prisma Priority enum value (e.g. "HIGH") or null for default
-};
-
-const TASK_REGEX = /^(\s*)(?:[-*]|\d+\.)\s+\[([ x])\]\s+(.+)$/;
-const MENTION_REGEX = /@([\w-]+)/g;
-const FILEREF_REGEX = /<([^>]+)>/g;
-const PRIORITY_REGEX = /!(low|medium|high|critical)\b/i;
-// Range: 2026-06-01..2026-06-05  — single: 2026-06-01
-// No \b anchors: the - inside dates is \W so \b fires mid-date and breaks matching.
-const DATE_RANGE_REGEX = /(\d{4}-\d{2}-\d{2})\.\.(\d{4}-\d{2}-\d{2})/;
-const DATE_REGEX       = /(\d{4}-\d{2}-\d{2})/;
-
-export function parseTasksFromMarkdown(content: string): ParsedTask[] {
-  const lines = content.split("\n");
-  const tasks: ParsedTask[] = [];
-
-  for (let i = 0; i < lines.length; i++) {
-    const match = TASK_REGEX.exec(lines[i]);
-    if (!match) continue;
-
-    const checked = match[2] === "x";
-    const text = match[3];
-
-    const mentionMatch = text.match(MENTION_REGEX);
-    const assigneeHandle = mentionMatch ? mentionMatch[0] : null;
-
-    const fileRefs: string[] = [];
-    let fileMatch: RegExpExecArray | null;
-    const fileRegex = new RegExp(FILEREF_REGEX.source, "g");
-    while ((fileMatch = fileRegex.exec(text)) !== null) {
-      fileRefs.push(fileMatch[1]);
-    }
-
-    // Try range first (2026-06-01..2026-06-05), then single date
-    const rangeMatch = DATE_RANGE_REGEX.exec(text);
-    const singleMatch = rangeMatch ? null : DATE_REGEX.exec(text);
-
-    const parsedStartDate = rangeMatch ? rangeMatch[1] : null;
-    const parsedDueDate   = rangeMatch ? rangeMatch[2] : (singleMatch ? singleMatch[1] : null);
-
-    const priorityMatch = PRIORITY_REGEX.exec(text);
-    const priority = priorityMatch ? priorityMatch[1].toUpperCase() : null;
-
-    const titleCandidate = text
-      .replace(/\[\[[^\]]*\]\]/g, "")   // strip [[note refs]]
-      .replace(/\(\([^)]*\)\)/g, "")    // strip ((task refs))
-      .replace(MENTION_REGEX, "")
-      .replace(FILEREF_REGEX, "")
-      .replace(DATE_RANGE_REGEX, "")
-      .replace(DATE_REGEX, "")
-      .replace(/!(low|medium|high|critical)\b/gi, "")
-      .replace(/\s*<!--task::[A-Z_]+-->/g, "")
-      .trim();
-
-    // If stripping dates leaves an empty title, keep the date string as the
-    // title so the task still gets created (e.g. "- [ ] 2026-05-20").
-    const hasRealTitle = titleCandidate.length > 0;
-    const startDate = hasRealTitle ? parsedStartDate : null;
-    const dueDate   = hasRealTitle ? parsedDueDate   : null;
-    const title     = hasRealTitle ? titleCandidate  : (parsedDueDate ?? parsedStartDate ?? "");
-
-    if (!title) continue; // truly empty — skip
-
-    tasks.push({ title, assigneeHandle, fileRefs, lineIndex: i, isChecked: checked, startDate, dueDate, priority });
-  }
-
-  return tasks;
-}
-
-// Only @agent is valid — identity tracked via MCP token, not handle name
-export function isAgentHandle(handle: string): boolean {
-  return handle.toLowerCase() === "@agent";
-}

package/lib/task-utils.ts

@@ -1,52 +0,0 @@
-/**
- * Shared utility functions for task operations
- */
-
-export interface TaskWithDueDate {
-  dueDate: string | Date | null;
-  status?: string;
-}
-
-/**
- * Check if a task is overdue.
- * Compares dates in local timezone (ignoring time component).
- * Returns false if task has no due date or is already done.
- */
-export function isOverdue(task: TaskWithDueDate): boolean {
-  if (!task.dueDate || task.status === "DONE") return false;
-
-  // Compare dates in local timezone, ignoring time component
-  const due = new Date(task.dueDate);
-  const today = new Date();
-
-  // Reset time components for pure date comparison
-  due.setHours(0, 0, 0, 0);
-  today.setHours(0, 0, 0, 0);
-
-  return due < today;
-}
-
-/**
- * Format a date for display relative to now (e.g., "3 days ago")
- */
-export function formatRelativeTime(date: string | Date): string {
-  const now = new Date();
-  const then = new Date(date);
-  const diffMs = now.getTime() - then.getTime();
-  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-
-  if (diffDays === 0) {
-    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
-    if (diffHours === 0) {
-      const diffMinutes = Math.floor(diffMs / (1000 * 60));
-      return diffMinutes <= 1 ? "just now" : `${diffMinutes} minutes ago`;
-    }
-    return diffHours === 1 ? "1 hour ago" : `${diffHours} hours ago`;
-  }
-
-  if (diffDays === 1) return "yesterday";
-  if (diffDays < 7) return `${diffDays} days ago`;
-  if (diffDays < 30) return `${Math.floor(diffDays / 7)} weeks ago`;
-  if (diffDays < 365) return `${Math.floor(diffDays / 30)} months ago`;
-  return `${Math.floor(diffDays / 365)} years ago`;
-}

package/lib/use-is-electron.ts

@@ -1,19 +0,0 @@
-"use client";
-
-import { useState, useEffect } from "react";
-
-/**
- * Returns `true` when running inside the Electron desktop app.
- * Detection relies on `window.electronAPI` which is exposed by
- * `electron/preload.ts` via `contextBridge.exposeInMainWorld`.
- * SSR-safe: returns `false` on the server and hydrates to the correct value.
- */
-export function useIsElectron() {
-  const [isElectron, setIsElectron] = useState(false);
-
-  useEffect(() => {
-    setIsElectron(typeof window !== "undefined" && "electronAPI" in window);
-  }, []);
-
-  return isElectron;
-}

package/lib/use-is-mobile.ts

@@ -1,22 +0,0 @@
-"use client";
-
-import { useState, useEffect } from "react";
-
-/**
- * Returns `true` when the viewport is narrower than the mobile breakpoint.
- * Uses `matchMedia` so it updates live on resize / orientation change.
- * SSR-safe: returns `false` on the server and hydrates to the correct value.
- */
-export function useIsMobile() {
-  const [isMobile, setIsMobile] = useState(false);
-
-  useEffect(() => {
-    const mq = window.matchMedia("(max-width: 767.98px)");
-    const update = () => setIsMobile(mq.matches);
-    update();
-    mq.addEventListener("change", update);
-    return () => mq.removeEventListener("change", update);
-  }, []);
-
-  return isMobile;
-}

package/lib/validation/calendar-feed.ts

@@ -1,31 +0,0 @@
-import { z } from "zod";
-import { MAX_FEED_LABEL_LEN, FEED_COLOR_KEYS, DEFAULT_FEED_COLOR } from "@/lib/limits";
-
-const urlSchema = z
-  .string()
-  .url("must be a valid URL")
-  .refine((u) => u.startsWith("https://"), "must be an https:// URL");
-
-const colorSchema = z.enum(FEED_COLOR_KEYS as unknown as [string, ...string[]]).default(DEFAULT_FEED_COLOR);
-
-export const createFeedSchema = z.object({
-  label: z
-    .string()
-    .trim()
-    .min(1, "label is required")
-    .max(MAX_FEED_LABEL_LEN, `label must be ≤ ${MAX_FEED_LABEL_LEN} chars`),
-  url: urlSchema,
-  color: colorSchema.optional(),
-});
-
-export const updateFeedSchema = z.object({
-  label: z
-    .string()
-    .trim()
-    .min(1, "label is required")
-    .max(MAX_FEED_LABEL_LEN, `label must be ≤ ${MAX_FEED_LABEL_LEN} chars`)
-    .optional(),
-  url: urlSchema.optional(),
-  color: z.enum(FEED_COLOR_KEYS as unknown as [string, ...string[]]).optional(),
-  enabled: z.boolean().optional(),
-});