@jant/core 0.3.37 → 0.3.39

package/src/node/runtime.ts

@@ -0,0 +1,88 @@
+import { serve, type ServerType } from "@hono/node-server";
+import type { AddressInfo } from "node:net";
+import type { App } from "../types/app-context.js";
+import type { Bindings } from "../types/bindings.js";
+import {
+  createNodeRequestHandler,
+  resolveHost,
+  resolvePort,
+} from "./request-handler.js";
+
+export {
+  applyNodeRuntimeEnvDefaults,
+  createNodeBindings,
+  createNodeRequestHandler,
+  migrate,
+  resolveDatabasePath,
+  resolveNodeAssetRoot,
+  resolveNodeDataDir,
+  resolveHost,
+  resolveNodeMigrationsDir,
+  resolvePort,
+  resolvePublicRequestUrl,
+} from "./request-handler.js";
+
+export interface NodeServerHandle {
+  close(): Promise<void>;
+  server: ServerType;
+  url: string;
+}
+
+export async function start(
+  env: Bindings = process.env as unknown as Bindings,
+  app?: App,
+): Promise<NodeServerHandle> {
+  const handler = await createNodeRequestHandler({
+    env,
+    app: async () => app ?? (await import("../app.js")).createApp(),
+  });
+  const hostname = resolveHost(env);
+  const port = resolvePort(env);
+
+  return new Promise<NodeServerHandle>((resolvePromise, reject) => {
+    let didResolve = false;
+    const server = serve(
+      { fetch: handler.fetch, hostname, port },
+      (info: AddressInfo) => {
+        didResolve = true;
+        server.off("error", onError);
+
+        let closed = false;
+        resolvePromise({
+          server,
+          url: `http://${info.address}:${info.port}`,
+          async close() {
+            if (closed) {
+              return;
+            }
+            closed = true;
+            await new Promise<void>((resolveClose, rejectClose) => {
+              server.close((error?: Error) => {
+                if (error) {
+                  rejectClose(error);
+                  return;
+                }
+                resolveClose();
+              });
+            });
+            await handler.close();
+          },
+        });
+      },
+    );
+
+    function onError(error: Error) {
+      if (didResolve) {
+        return;
+      }
+      try {
+        void handler.close();
+      } catch {
+        // ignore cleanup failure
+      }
+      reject(error);
+    }
+
+    server.once("error", onError);
+  });
+}

package/src/preset.css

@@ -9,6 +9,7 @@
 
 @import "basecoat-css";
 @plugin "@tailwindcss/typography";
+@import "./styles/fonts/latin.css";
 @import "./styles/components.css";
 @import "./styles/tokens.css";
 @import "./styles/ui.css";
@@ -38,7 +39,7 @@
  * Source: basecoat-css@0.3.11 .dark { } block
  */
 @media (prefers-color-scheme: dark) {
-  :root {
+  :root:not([data-theme-mode="light"]) {
     color-scheme: dark;
     --background: oklch(0.145 0 0);
     --foreground: oklch(0.985 0 0);
@@ -71,6 +72,38 @@
   }
 }
 
+:root[data-theme-mode="dark"] {
+  color-scheme: dark;
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.205 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.269 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.922 0 0);
+  --primary-foreground: oklch(0.205 0 0);
+  --secondary: oklch(0.269 0 0);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.269 0 0);
+  --muted-foreground: oklch(0.708 0 0);
+  --accent: oklch(0.371 0 0);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: oklch(0.556 0 0);
+  --sidebar: oklch(0.205 0 0);
+  --sidebar-foreground: oklch(0.985 0 0);
+  --sidebar-primary: oklch(0.488 0.243 264.376);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.269 0 0);
+  --sidebar-accent-foreground: oklch(0.985 0 0);
+  --sidebar-border: oklch(1 0 0 / 10%);
+  --sidebar-ring: oklch(0.439 0 0);
+  --scrollbar-thumb: rgba(255, 255, 255, 0.3);
+  --success: oklch(0.627 0.194 149.214);
+}
+
 /**
  * Typography (prose) — integrate with BaseCoat theme colors.
  *
@@ -78,16 +111,16 @@
  * We override them to use BaseCoat's CSS variables so that:
  *   - Light/dark mode switches automatically
  *   - Prose text matches the rest of the theme
- *   - Links are understated (same color as text, underline only)
+ *   - Links use the theme accent without reading like UI chrome
  *
- * Design reference: Medium, Substack, NYT — body links inherit text
- * color and rely on underline as the sole affordance.
+ * Design reference: editorial reading surfaces where links feel
+ * integrated into the text, not like product controls.
  */
 .prose {
   --tw-prose-body: inherit;
   --tw-prose-headings: var(--color-foreground);
   --tw-prose-lead: var(--color-muted-foreground);
-  --tw-prose-links: inherit;
+  --tw-prose-links: var(--site-accent);
   --tw-prose-bold: inherit;
   --tw-prose-counters: var(--color-muted-foreground);
   --tw-prose-bullets: var(--color-muted-foreground);
@@ -101,20 +134,15 @@
   --tw-prose-pre-bg: var(--color-muted);
   --tw-prose-th-borders: var(--color-border);
   --tw-prose-td-borders: var(--color-border);
-
-  /* Links: same color as surrounding text, underline only, no bold */
-  a {
-    font-weight: inherit;
-    text-underline-offset: 2px;
-    text-decoration-color: var(--color-border);
-  }
-
-  a:hover {
-    text-decoration-color: currentColor;
-  }
+  font-size: var(--type-body-size);
+  line-height: var(--type-body-leading);
+  letter-spacing: var(--type-body-tracking);
 
   :where(h1, h2, h3, h4, h5, h6) {
     font-family: var(--font-heading);
+    font-weight: var(--type-heading-weight);
+    letter-spacing: var(--type-heading-tracking);
+    line-height: var(--type-heading-leading);
   }
 
   /* Image figures */
@@ -155,3 +183,32 @@
     border-radius: 0;
   }
 }
+
+/*
+ * Content links
+ *
+ * Used by long-form prose and a few non-prose reading samples.
+ * UI/navigation links should use their own component styles instead.
+ */
+.content-link,
+.prose a {
+  color: var(--site-accent);
+  font-weight: inherit;
+  text-decoration: underline;
+  text-decoration-color: color-mix(
+    in srgb,
+    var(--site-accent) 58%,
+    transparent
+  );
+  text-decoration-thickness: 1px;
+  text-underline-offset: 0.14em;
+  transition:
+    color 0.18s ease,
+    text-decoration-color 0.18s ease;
+}
+
+.content-link:hover,
+.prose a:hover {
+  color: color-mix(in srgb, var(--site-accent) 84%, var(--color-foreground));
+  text-decoration-color: currentColor;
+}

package/src/routes/__tests__/compose.test.ts

@@ -2,6 +2,36 @@ import { describe, it, expect } from "vitest";
 import { createTestApp } from "../../__tests__/helpers/app.js";
 import { composeRoutes } from "../compose.js";
 
+function createMockStorage() {
+  const files = new Map<string, { body: Uint8Array; contentType?: string }>();
+
+  return {
+    files,
+    async put(
+      key: string,
+      body: Uint8Array | ReadableStream,
+      opts?: { contentType?: string },
+    ) {
+      const bytes =
+        body instanceof Uint8Array
+          ? body
+          : new Uint8Array(await new Response(body).arrayBuffer());
+      files.set(key, { body: bytes, contentType: opts?.contentType });
+    },
+    async get(key: string) {
+      const file = files.get(key);
+      if (!file) return null;
+      return {
+        body: new Response(file.body).body as ReadableStream,
+        contentType: file.contentType,
+      };
+    },
+    async delete(key: string) {
+      files.delete(key);
+    },
+  };
+}
+
 describe("Compose Routes", () => {
   describe("POST /compose", () => {
     it("redirects to signin when not authenticated", async () => {
@@ -53,6 +83,7 @@ describe("Compose Routes", () => {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
           format: "link",
+          title: "Example link",
           bodyMarkdown: "Check this out",
           url: "https://example.com",
         }),
@@ -78,7 +109,7 @@ describe("Compose Routes", () => {
           format: "quote",
           bodyMarkdown: "Great insight",
           quoteText: "The original quote",
-          url: "https://example.com/source",
+          sourceUrl: "https://example.com/source",
         }),
       });
 
@@ -136,7 +167,7 @@ describe("Compose Routes", () => {
       expect(text).toContain("toast-error");
     });
 
-    it("attaches media IDs when provided", async () => {
+    it("attaches ordered attachment inputs when provided", async () => {
       const { app, services } = createTestApp({ authenticated: true });
       app.route("/compose", composeRoutes);
 
@@ -146,7 +177,7 @@ describe("Compose Routes", () => {
         originalName: "test.jpg",
         mimeType: "image/jpeg",
         size: 1024,
-        storageKey: "media/2025/01/test.jpg",
+        storageKey: "media/test.jpg",
         width: 800,
         height: 600,
       });
@@ -157,7 +188,7 @@ describe("Compose Routes", () => {
         body: JSON.stringify({
           format: "note",
           bodyMarkdown: "Post with media",
-          mediaIds: [media.id],
+          attachments: [{ type: "media", mediaId: media.id }],
         }),
       });
 
@@ -172,6 +203,48 @@ describe("Compose Routes", () => {
       expect(attachments[0].id).toBe(media.id);
     });
 
+    it("creates inline text attachments through the shared attachments schema", async () => {
+      const storage = createMockStorage();
+      const { app, services } = createTestApp({
+        authenticated: true,
+        storage,
+      });
+      app.route("/compose", composeRoutes);
+
+      const res = await app.request("/compose", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          format: "note",
+          bodyMarkdown: "Post with attached text",
+          attachments: [
+            {
+              type: "text",
+              contentFormat: "markdown",
+              content: "Attached body",
+              summary: "Attached body",
+            },
+          ],
+        }),
+      });
+
+      expect(res.status).toBe(200);
+
+      const posts = await services.posts.list();
+      expect(posts).toHaveLength(1);
+
+      const attachments = await services.media.getByPostId(posts[0].id);
+      expect(attachments).toHaveLength(1);
+      expect(attachments[0].mimeType).toBe("text/x-tiptap+json");
+
+      const content = await services.media.getTextAttachmentContent(
+        attachments[0].id,
+        storage,
+      );
+      expect(content?.content).toBe("Attached body");
+      expect(storage.files.size).toBe(1);
+    });
+
     it("resets compose signals after publishing", async () => {
       const { app } = createTestApp({ authenticated: true });
       app.route("/compose", composeRoutes);

package/src/routes/api/__tests__/attachments.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { attachmentsApiRoutes } from "../attachments.js";
+
+function createMockStorage() {
+  const files = new Map<string, { body: Uint8Array; contentType?: string }>();
+
+  return {
+    files,
+    async put(
+      key: string,
+      body: Uint8Array | ReadableStream,
+      opts?: { contentType?: string },
+    ) {
+      const bytes =
+        body instanceof Uint8Array
+          ? body
+          : new Uint8Array(await new Response(body).arrayBuffer());
+      files.set(key, { body: bytes, contentType: opts?.contentType });
+    },
+    async get(key: string) {
+      const file = files.get(key);
+      if (!file) return null;
+      return {
+        body: new Response(file.body).body as ReadableStream,
+        contentType: file.contentType,
+      };
+    },
+    async delete(key: string) {
+      files.delete(key);
+    },
+  };
+}
+
+describe("Attachments API Routes", () => {
+  it("returns 401 when not authenticated", async () => {
+    const storage = createMockStorage();
+    const { app } = createTestApp({ authenticated: false, storage });
+    app.route("/api/attachments", attachmentsApiRoutes);
+
+    const res = await app.request(
+      "/api/attachments/00000000-0000-0000-0000-000000000001/content",
+    );
+    expect(res.status).toBe(401);
+  });
+
+  it("returns markdown content for text attachments", async () => {
+    const storage = createMockStorage();
+    const { app, services } = createTestApp({ authenticated: true, storage });
+    app.route("/api/attachments", attachmentsApiRoutes);
+
+    const attachment = await services.media.createTextAttachment(
+      {
+        contentFormat: "markdown",
+        content: "# Heading\n\nBody text",
+      },
+      {
+        storage,
+        storageDriver: "local",
+        maxFileSizeMB: 1,
+      },
+    );
+
+    const res = await app.request(`/api/attachments/${attachment.id}/content`);
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toEqual({
+      id: attachment.id,
+      type: "text",
+      contentFormat: "markdown",
+      content: "# Heading\n\nBody text",
+      summary: "Heading Body text",
+      chars: 17,
+    });
+  });
+
+  it("returns 404 for non-text attachments", async () => {
+    const storage = createMockStorage();
+    const { app, services } = createTestApp({ authenticated: true, storage });
+    app.route("/api/attachments", attachmentsApiRoutes);
+
+    const media = await services.media.create({
+      filename: "photo.jpg",
+      originalName: "photo.jpg",
+      mimeType: "image/jpeg",
+      size: 1024,
+      storageKey: "media/photo.jpg",
+    });
+
+    const res = await app.request(`/api/attachments/${media.id}/content`);
+    expect(res.status).toBe(404);
+  });
+});

package/src/routes/api/__tests__/collections.test.ts

@@ -1,5 +1,7 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi } from "vitest";
 import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { createEntityId } from "../../../lib/ids.js";
+import { MAX_COLLECTION_SLUG_LENGTH } from "../../../types.js";
 import { collectionsApiRoutes } from "../collections.js";
 
 describe("Collections API Routes", () => {
@@ -36,11 +38,73 @@ describe("Collections API Routes", () => {
       expect(body.collections).toHaveLength(1);
       expect(body.collections[0].slug).toBe("tech");
       expect(body.collections[0].postCount).toBe(1);
+      expect(body.collections[0].recentActivityAt).toBe(post.lastActivityAt);
 
       expect(body.sidebarItems).toHaveLength(1);
       expect(body.sidebarItems[0].type).toBe("collection");
       expect(body.sidebarItems[0].collectionId).toBe(col.id);
     });
+
+    it("returns divider labels", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const divider = await services.collections.createSidebarItem(
+        "divider",
+        undefined,
+        "Notes",
+      );
+
+      const res = await app.request("/api/collections");
+      const body = await res.json();
+
+      expect(body.sidebarItems).toContainEqual(
+        expect.objectContaining({
+          id: divider.id,
+          type: "divider",
+          label: "Notes",
+        }),
+      );
+    });
+
+    it("returns compose-sorted collections when view=compose", async () => {
+      vi.useFakeTimers();
+
+      try {
+        const { app, services } = createTestApp({ authenticated: true });
+        app.route("/api/collections", collectionsApiRoutes);
+
+        vi.setSystemTime(new Date("2024-01-01T00:00:00Z"));
+        const older = await services.collections.create({
+          slug: "older",
+          title: "Older",
+        });
+
+        vi.setSystemTime(new Date("2024-01-01T00:00:10Z"));
+        const newer = await services.collections.create({
+          slug: "newer",
+          title: "Newer",
+        });
+
+        vi.setSystemTime(new Date("2024-01-01T00:01:00Z"));
+        await services.posts.create({
+          format: "note",
+          bodyMarkdown: "shared add",
+          collectionIds: [older.id, newer.id],
+        });
+
+        const res = await app.request("/api/collections?view=compose");
+        expect(res.status).toBe(200);
+
+        const body = await res.json();
+        expect(body.sidebarItems).toEqual([]);
+        expect(
+          body.collections.map((collection: { id: string }) => collection.id),
+        ).toEqual([newer.id, older.id]);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
   });
 
   describe("GET /api/collections/:id", () => {
@@ -72,10 +136,9 @@ describe("Collections API Routes", () => {
     it("returns 404 for non-existent collection", async () => {
       const { app } = createTestApp();
       app.route("/api/collections", collectionsApiRoutes);
+      const missingId = createEntityId("collection");
 
-      const res = await app.request(
-        `/api/collections/${"00000000-0000-0000-0000-000000009999"}`,
-      );
+      const res = await app.request(`/api/collections/${missingId}`);
       expect(res.status).toBe(404);
     });
   });
@@ -127,6 +190,39 @@ describe("Collections API Routes", () => {
 
       expect(res.status).toBe(400);
     });
+
+    it("rejects rating_asc as a collection sort order", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          slug: "tech",
+          title: "Tech",
+          sortOrder: "rating_asc",
+        }),
+      });
+
+      expect(res.status).toBe(400);
+    });
+
+    it("rejects slugs longer than the maximum length", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request("/api/collections", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          slug: "a".repeat(MAX_COLLECTION_SLUG_LENGTH + 1),
+          title: "Tech",
+        }),
+      });
+
+      expect(res.status).toBe(400);
+    });
   });
 
   describe("PUT /api/collections/:id", () => {
@@ -153,15 +249,13 @@ describe("Collections API Routes", () => {
     it("returns 404 for non-existent collection", async () => {
       const { app } = createTestApp({ authenticated: true });
       app.route("/api/collections", collectionsApiRoutes);
+      const missingId = createEntityId("collection");
 
-      const res = await app.request(
-        `/api/collections/${"00000000-0000-0000-0000-000000009999"}`,
-        {
-          method: "PUT",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ title: "test" }),
-        },
-      );
+      const res = await app.request(`/api/collections/${missingId}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ title: "test" }),
+      });
 
       expect(res.status).toBe(404);
     });
@@ -208,11 +302,11 @@ describe("Collections API Routes", () => {
     it("returns 404 for non-existent collection", async () => {
       const { app } = createTestApp({ authenticated: true });
       app.route("/api/collections", collectionsApiRoutes);
+      const missingId = createEntityId("collection");
 
-      const res = await app.request(
-        `/api/collections/${"00000000-0000-0000-0000-000000009999"}`,
-        { method: "DELETE" },
-      );
+      const res = await app.request(`/api/collections/${missingId}`, {
+        method: "DELETE",
+      });
 
       expect(res.status).toBe(404);
     });
@@ -253,6 +347,28 @@ describe("Collections API Routes", () => {
     });
   });
 
+  describe("PUT /api/collections/sidebar-items/:id", () => {
+    it("updates a divider label", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const item = await services.collections.createSidebarItem("divider");
+
+      const res = await app.request(
+        `/api/collections/sidebar-items/${item.id}`,
+        {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ label: "Reading" }),
+        },
+      );
+
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.label).toBe("Reading");
+    });
+  });
+
   describe("PUT /api/collections/sidebar-items/:id/move", () => {
     it("moves a sidebar item", async () => {
       const { app, services } = createTestApp({ authenticated: true });
@@ -319,20 +435,18 @@ describe("Collections API Routes", () => {
     it("returns 404 for non-existent collection", async () => {
       const { app, services } = createTestApp({ authenticated: true });
       app.route("/api/collections", collectionsApiRoutes);
+      const missingId = createEntityId("collection");
 
       const post = await services.posts.create({
         format: "note",
         bodyMarkdown: "test",
       });
 
-      const res = await app.request(
-        `/api/collections/${"00000000-0000-0000-0000-000000009999"}/posts`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ postId: post.id }),
-        },
-      );
+      const res = await app.request(`/api/collections/${missingId}/posts`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ postId: post.id }),
+      });
 
       expect(res.status).toBe(404);
     });