@autumnsgrove/groveengine 0.9.4 → 0.9.6

package/dist/components/custom/GutterItem.svelte

@@ -63,7 +63,7 @@
 		{#if item.images?.length > 0}
 			<div class="gutter-gallery">
 				<GlassCarousel
-					images={item.images.map(img => ({ url: img.url, alt: img.alt || 'Gallery image', caption: img.caption }))}
+					images={item.images.map((/** @type {{url?: string, alt?: string, caption?: string}} */ img) => ({ url: img.url || '', alt: img.alt || 'Gallery image', caption: img.caption || '' }))}
 					variant="frosted"
 					showArrows={false}
 					class="gutter-carousel"

package/dist/config/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./ai-models.js";
 export * from "./domain-blocklist.js";
 export * from "./offensive-blocklist.js";
+export * from "./presets.js";
 export * from "./tiers.js";

package/dist/config/index.js

@@ -3,4 +3,5 @@
 export * from "./ai-models.js";
 export * from "./domain-blocklist.js";
 export * from "./offensive-blocklist.js";
+export * from "./presets.js";
 export * from "./tiers.js";

package/dist/config/presets.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared UI Presets
+ *
+ * Unified color and design presets used across the Grove ecosystem.
+ * This ensures consistency between Plant signup and Arbor admin panel.
+ */
+export interface ColorPreset {
+    /** Display name */
+    name: string;
+    /** Hex color value (e.g., "#16a34a") */
+    hex: string;
+    /** HSL values as string (e.g., "142 76% 36%") - used for CSS custom properties */
+    hsl: string;
+}
+/**
+ * Grove Nature Color Palette
+ *
+ * A curated set of colors inspired by nature, designed to feel
+ * warm and organic. These appear in the signup flow and settings panel.
+ */
+export declare const COLOR_PRESETS: ColorPreset[];
+/**
+ * Default accent color (Grove Green)
+ */
+export declare const DEFAULT_ACCENT_COLOR = "#16a34a";
+/**
+ * Font presets with display info
+ */
+export interface FontPreset {
+    /** Internal ID used in database */
+    id: string;
+    /** Display name */
+    name: string;
+    /** CSS font-family stack */
+    family: string;
+    /** Description for settings UI */
+    description: string;
+    /** Category for grouping */
+    category: "accessibility" | "sans-serif" | "monospace" | "display";
+}
+export declare const FONT_PRESETS: FontPreset[];
+export declare const DEFAULT_FONT = "lexend";
+/**
+ * Get font family by ID
+ */
+export declare function getFontFamily(id: string): string;

package/dist/config/presets.js

@@ -0,0 +1,120 @@
+/**
+ * Shared UI Presets
+ *
+ * Unified color and design presets used across the Grove ecosystem.
+ * This ensures consistency between Plant signup and Arbor admin panel.
+ */
+/**
+ * Grove Nature Color Palette
+ *
+ * A curated set of colors inspired by nature, designed to feel
+ * warm and organic. These appear in the signup flow and settings panel.
+ */
+export const COLOR_PRESETS = [
+    // Greens - The Grove
+    { name: "Grove Green", hex: "#16a34a", hsl: "142 76% 36%" },
+    { name: "Meadow Green", hex: "#22c55e", hsl: "142 76% 45%" },
+    // Blues - Water
+    { name: "Ocean Blue", hex: "#0284c7", hsl: "200 90% 40%" },
+    // Purples - Twilight
+    { name: "Deep Plum", hex: "#581c87", hsl: "274 79% 32%" },
+    { name: "Violet Purple", hex: "#8b5cf6", hsl: "271 76% 53%" },
+    { name: "Lavender", hex: "#a78bfa", hsl: "271 50% 68%" },
+    // Pinks - Blossoms
+    { name: "Cherry Blossom", hex: "#ec4899", hsl: "330 81% 60%" },
+    { name: "Tulip Pink", hex: "#f9a8d4", hsl: "330 71% 79%" },
+    // Warm - Autumn & Ember
+    { name: "Sunset Ember", hex: "#c2410c", hsl: "20 86% 42%" },
+    { name: "Golden Amber", hex: "#d97706", hsl: "38 92% 50%" },
+    { name: "Autumn Gold", hex: "#eab308", hsl: "43 96% 56%" },
+    // Red - Cardinal
+    { name: "Cardinal Red", hex: "#dc2626", hsl: "0 75% 51%" },
+];
+/**
+ * Default accent color (Grove Green)
+ */
+export const DEFAULT_ACCENT_COLOR = "#16a34a";
+export const FONT_PRESETS = [
+    // Accessibility fonts
+    {
+        id: "lexend",
+        name: "Lexend",
+        family: "'Lexend', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+        description: "Modern accessibility font for reading fluency (default)",
+        category: "accessibility",
+    },
+    {
+        id: "atkinson",
+        name: "Atkinson Hyperlegible",
+        family: "'Atkinson Hyperlegible', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+        description: "Accessibility font for low vision readers",
+        category: "accessibility",
+    },
+    {
+        id: "opendyslexic",
+        name: "OpenDyslexic",
+        family: "'OpenDyslexic', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+        description: "Accessibility font for dyslexia",
+        category: "accessibility",
+    },
+    // Sans-serif
+    {
+        id: "quicksand",
+        name: "Quicksand",
+        family: "'Quicksand', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+        description: "Rounded, friendly geometric sans-serif",
+        category: "sans-serif",
+    },
+    {
+        id: "plus-jakarta-sans",
+        name: "Plus Jakarta Sans",
+        family: "'Plus Jakarta Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+        description: "Contemporary geometric sans, balanced and versatile",
+        category: "sans-serif",
+    },
+    // Monospace
+    {
+        id: "ibm-plex-mono",
+        name: "IBM Plex Mono",
+        family: "'IBM Plex Mono', 'Courier New', Consolas, monospace",
+        description: "Clean, highly readable code font",
+        category: "monospace",
+    },
+    {
+        id: "cozette",
+        name: "Cozette",
+        family: "'Cozette', 'Courier New', Consolas, monospace",
+        description: "Bitmap-style programming font, retro aesthetic",
+        category: "monospace",
+    },
+    // Display/Special
+    {
+        id: "alagard",
+        name: "Alagard",
+        family: "'Alagard', fantasy, cursive",
+        description: "Medieval pixel font for fantasy vibes",
+        category: "display",
+    },
+    {
+        id: "calistoga",
+        name: "Calistoga",
+        family: "'Calistoga', Georgia, serif",
+        description: "Casual brush serif, warm and friendly",
+        category: "display",
+    },
+    {
+        id: "caveat",
+        name: "Caveat",
+        family: "'Caveat', cursive, sans-serif",
+        description: "Handwritten script, personal and informal",
+        category: "display",
+    },
+];
+export const DEFAULT_FONT = "lexend";
+/**
+ * Get font family by ID
+ */
+export function getFontFamily(id) {
+    const font = FONT_PRESETS.find((f) => f.id === id);
+    return font?.family ?? FONT_PRESETS[0].family;
+}

package/dist/config/tiers.d.ts

@@ -78,6 +78,16 @@ export interface TierConfig {
     support: TierSupport;
 }
 export declare const TIERS: Record<TierKey, TierConfig>;
+/**
+ * Default tier used when tier is unknown, invalid, or not yet determined.
+ * Used as a safe fallback throughout the codebase to ensure consistent behavior.
+ *
+ * Seedling is the default because:
+ * - It's the entry-level paid tier with reasonable limits
+ * - Free tier doesn't have blog access, so can't be a safe default
+ * - It provides a good baseline without being overly permissive
+ */
+export declare const DEFAULT_TIER: TierKey;
 export declare const TIER_ORDER: TierKey[];
 export declare const PAID_TIERS: PaidTierKey[];
 /**

package/dist/config/tiers.js

@@ -292,6 +292,19 @@ export const TIERS = {
     },
 };
 // =============================================================================
+// CONSTANTS
+// =============================================================================
+/**
+ * Default tier used when tier is unknown, invalid, or not yet determined.
+ * Used as a safe fallback throughout the codebase to ensure consistent behavior.
+ *
+ * Seedling is the default because:
+ * - It's the entry-level paid tier with reasonable limits
+ * - Free tier doesn't have blog access, so can't be a safe default
+ * - It provides a good baseline without being overly permissive
+ */
+export const DEFAULT_TIER = "seedling";
+// =============================================================================
 // HELPER ARRAYS
 // =============================================================================
 export const TIER_ORDER = [

package/dist/durable-objects/PostContentDO.d.ts

@@ -0,0 +1,62 @@
+/**
+ * PostContentDO - Per-Post Durable Object for Content Caching
+ *
+ * Handles static content that rarely changes:
+ * - Cached rendered HTML
+ * - Markdown source
+ * - Post metadata (title, description, tags)
+ *
+ * This DO hibernates quickly since content doesn't change often.
+ * Separated from PostMetaDO for cost efficiency.
+ *
+ * ID Pattern: content:{tenantId}:{slug}
+ *
+ * Part of the Loom pattern - Grove's coordination layer.
+ */
+export interface PostContent {
+    tenantId: string;
+    slug: string;
+    title: string;
+    description: string;
+    tags: string[];
+    markdownContent: string;
+    htmlContent: string;
+    gutterContent: string;
+    font: string;
+    publishedAt: number | null;
+    updatedAt: number;
+    storageLocation: "hot" | "warm" | "cold";
+    r2Key?: string;
+}
+export interface ContentUpdate {
+    title?: string;
+    description?: string;
+    tags?: string[];
+    markdownContent?: string;
+    htmlContent?: string;
+    gutterContent?: string;
+    font?: string;
+}
+export declare class PostContentDO implements DurableObject {
+    private state;
+    private env;
+    private content;
+    private initialized;
+    constructor(state: DurableObjectState, env: Env);
+    private initializeStorage;
+    fetch(request: Request): Promise<Response>;
+    private handleGetContent;
+    private handleSetContent;
+    private handleUpdateContent;
+    private handleGetHtml;
+    private handleInvalidate;
+    private handleMigrateToCold;
+    private fetchFromR2;
+    private persistContent;
+}
+interface Env {
+    DB: D1Database;
+    CACHE_KV: KVNamespace;
+    IMAGES: R2Bucket;
+}
+export {};

package/dist/durable-objects/PostContentDO.js

@@ -0,0 +1,231 @@
+/// <reference types="@cloudflare/workers-types" />
+// ============================================================================
+// PostContentDO Class
+// ============================================================================
+export class PostContentDO {
+    state;
+    env;
+    content = null;
+    initialized = false;
+    constructor(state, env) {
+        this.state = state;
+        this.env = env;
+        this.state.blockConcurrencyWhile(async () => {
+            await this.initializeStorage();
+        });
+    }
+    async initializeStorage() {
+        if (this.initialized)
+            return;
+        await this.state.storage.sql.exec(`
+      CREATE TABLE IF NOT EXISTS content (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+    `);
+        const stored = this.state.storage.sql
+            .exec("SELECT value FROM content WHERE key = 'post_content'")
+            .one();
+        if (stored?.value) {
+            this.content = JSON.parse(stored.value);
+        }
+        this.initialized = true;
+    }
+    async fetch(request) {
+        const url = new URL(request.url);
+        const path = url.pathname;
+        try {
+            if (path === "/content" && request.method === "GET") {
+                return this.handleGetContent();
+            }
+            if (path === "/content" && request.method === "PUT") {
+                return this.handleSetContent(request);
+            }
+            if (path === "/content" && request.method === "PATCH") {
+                return this.handleUpdateContent(request);
+            }
+            if (path === "/content/html" && request.method === "GET") {
+                return this.handleGetHtml();
+            }
+            if (path === "/content/invalidate" && request.method === "POST") {
+                return this.handleInvalidate();
+            }
+            if (path === "/content/migrate" && request.method === "POST") {
+                return this.handleMigrateToCold(request);
+            }
+            return new Response("Not found", { status: 404 });
+        }
+        catch (err) {
+            console.error("[PostContentDO] Error:", err);
+            return new Response(JSON.stringify({
+                error: err instanceof Error ? err.message : "Internal error",
+            }), { status: 500, headers: { "Content-Type": "application/json" } });
+        }
+    }
+    async handleGetContent() {
+        if (!this.content) {
+            return new Response("Content not found", { status: 404 });
+        }
+        if (this.content.storageLocation === "cold" && this.content.r2Key) {
+            const r2Content = await this.fetchFromR2(this.content.r2Key);
+            if (r2Content) {
+                return Response.json({ ...this.content, ...r2Content });
+            }
+        }
+        return Response.json(this.content);
+    }
+    async handleSetContent(request) {
+        const data = (await request.json());
+        if (!data.tenantId || !data.slug || !data.title) {
+            return new Response("Missing required fields", { status: 400 });
+        }
+        this.content = {
+            tenantId: data.tenantId,
+            slug: data.slug,
+            title: data.title,
+            description: data.description || "",
+            tags: data.tags || [],
+            markdownContent: data.markdownContent || "",
+            htmlContent: data.htmlContent || "",
+            gutterContent: data.gutterContent || "[]",
+            font: data.font || "default",
+            publishedAt: data.publishedAt || null,
+            updatedAt: Date.now(),
+            storageLocation: "hot",
+        };
+        await this.persistContent();
+        return Response.json({ success: true, content: this.content });
+    }
+    async handleUpdateContent(request) {
+        if (!this.content) {
+            return new Response("Content not found", { status: 404 });
+        }
+        const updates = (await request.json());
+        if (updates.title !== undefined)
+            this.content.title = updates.title;
+        if (updates.description !== undefined)
+            this.content.description = updates.description;
+        if (updates.tags !== undefined)
+            this.content.tags = updates.tags;
+        if (updates.markdownContent !== undefined)
+            this.content.markdownContent = updates.markdownContent;
+        if (updates.htmlContent !== undefined)
+            this.content.htmlContent = updates.htmlContent;
+        if (updates.gutterContent !== undefined)
+            this.content.gutterContent = updates.gutterContent;
+        if (updates.font !== undefined)
+            this.content.font = updates.font;
+        this.content.updatedAt = Date.now();
+        await this.persistContent();
+        return Response.json({ success: true, content: this.content });
+    }
+    async handleGetHtml() {
+        if (!this.content) {
+            return new Response("Content not found", { status: 404 });
+        }
+        if (this.content.storageLocation === "cold" && this.content.r2Key) {
+            const r2Content = await this.fetchFromR2(this.content.r2Key);
+            if (r2Content?.htmlContent) {
+                return new Response(r2Content.htmlContent, {
+                    headers: { "Content-Type": "text/html" },
+                });
+            }
+        }
+        return new Response(this.content.htmlContent, {
+            headers: { "Content-Type": "text/html" },
+        });
+    }
+    async handleInvalidate() {
+        this.content = null;
+        await this.state.storage.sql.exec("DELETE FROM content WHERE key = 'post_content'");
+        return Response.json({ success: true, message: "Content invalidated" });
+    }
+    async handleMigrateToCold(request) {
+        if (!this.content) {
+            return new Response("Content not found", { status: 404 });
+        }
+        const data = (await request.json());
+        if (!data.r2Key) {
+            return new Response("R2 key required", { status: 400 });
+        }
+        const r2 = this.env.IMAGES;
+        if (!r2) {
+            return new Response("R2 not configured", { status: 500 });
+        }
+        // Prepare content payload before modifying state
+        const contentPayload = JSON.stringify({
+            markdownContent: this.content.markdownContent,
+            htmlContent: this.content.htmlContent,
+            gutterContent: this.content.gutterContent,
+        });
+        // Upload to R2 with retry logic
+        const maxRetries = 3;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await r2.put(data.r2Key, contentPayload, {
+                    httpMetadata: { contentType: "application/json" },
+                });
+                // Verify upload succeeded by checking object exists
+                const verification = await r2.head(data.r2Key);
+                if (!verification) {
+                    throw new Error("R2 upload verification failed - object not found");
+                }
+                // Atomic state update: prepare new state, persist, then update memory
+                // This prevents partial state if persistContent() fails
+                const updatedContent = {
+                    ...this.content,
+                    markdownContent: "", // Clear after moving to R2
+                    htmlContent: "",
+                    gutterContent: "[]",
+                    storageLocation: "cold",
+                    r2Key: data.r2Key,
+                };
+                // Persist BEFORE modifying in-memory state (atomic operation)
+                await this.state.storage.sql.exec("INSERT OR REPLACE INTO content (key, value, updated_at) VALUES (?, ?, ?)", "post_content", JSON.stringify(updatedContent), Date.now());
+                // Only after successful persistence, update in-memory state
+                this.content = updatedContent;
+                return Response.json({
+                    success: true,
+                    message: "Migrated to cold storage",
+                    r2Key: data.r2Key,
+                });
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                console.error(`[PostContentDO] R2 upload attempt ${attempt}/${maxRetries} failed:`, lastError.message);
+                if (attempt < maxRetries) {
+                    // Exponential backoff: 100ms, 200ms, 400ms
+                    await new Promise((resolve) => setTimeout(resolve, 100 * Math.pow(2, attempt - 1)));
+                }
+            }
+        }
+        // All retries failed - return error without modifying local state
+        return new Response(JSON.stringify({
+            error: "R2 migration failed after retries",
+            details: lastError?.message,
+        }), { status: 500, headers: { "Content-Type": "application/json" } });
+    }
+    async fetchFromR2(key) {
+        const r2 = this.env.IMAGES;
+        if (!r2)
+            return null;
+        try {
+            const object = await r2.get(key);
+            if (!object)
+                return null;
+            const text = await object.text();
+            return JSON.parse(text);
+        }
+        catch (err) {
+            console.error("[PostContentDO] R2 fetch error:", err);
+            return null;
+        }
+    }
+    async persistContent() {
+        if (!this.content)
+            return;
+        await this.state.storage.sql.exec("INSERT OR REPLACE INTO content (key, value, updated_at) VALUES (?, ?, ?)", "post_content", JSON.stringify(this.content), Date.now());
+    }
+}

package/dist/durable-objects/PostMetaDO.d.ts

@@ -0,0 +1,98 @@
+/**
+ * PostMetaDO - Per-Post Durable Object for Hot Data
+ *
+ * Handles data that changes frequently and benefits from staying awake:
+ * - Reaction counts (likes, bookmarks)
+ * - View counts and analytics
+ * - Real-time presence (who's reading)
+ * - WebSocket connections for live updates
+ *
+ * ID Pattern: post:{tenantId}:{slug}
+ *
+ * Part of the Loom pattern - Grove's coordination layer.
+ * Split from PostContentDO for optimal hibernation behavior.
+ */
+import { type TierKey } from "../config/tiers.js";
+export interface PostMeta {
+    tenantId: string;
+    slug: string;
+    tier?: TierKey;
+    viewCount: number;
+    reactions: ReactionCounts;
+    lastViewed: number;
+    isPopular: boolean;
+}
+export interface ReactionCounts {
+    likes: number;
+    bookmarks: number;
+}
+export interface ReactionEvent {
+    type: "like" | "bookmark";
+    action: "add" | "remove";
+    userId?: string;
+    timestamp: number;
+}
+export interface PresenceInfo {
+    activeReaders: number;
+    lastActivity: number;
+}
+export declare class PostMetaDO implements DurableObject {
+    private state;
+    private env;
+    private meta;
+    private presence;
+    private connections;
+    private initialized;
+    private isDirty;
+    private lastPersist;
+    private viewInsertsSinceCheck;
+    constructor(state: DurableObjectState, env: Env);
+    private initializeStorage;
+    fetch(request: Request): Promise<Response>;
+    private handleGetMeta;
+    private handleInitMeta;
+    private handleRecordView;
+    private handleGetReactions;
+    private handleAddReaction;
+    private handleRemoveReaction;
+    private handleGetPresence;
+    /**
+     * Handle WebSocket connection for real-time presence updates.
+     *
+     * SECURITY NOTE: Anonymous WebSocket access is intentional.
+     * This endpoint provides read-only presence data ("N people reading")
+     * which is public information suitable for any blog visitor. The data
+     * exposed (reader count, reaction counts) is already visible on the
+     * public blog page. No authentication is required because:
+     * - No sensitive data is transmitted
+     * - No state-changing operations are available via WebSocket
+     * - Presence tracking uses anonymous session IDs, not user identities
+     *
+     * If private analytics are needed in the future, that would go through
+     * authenticated API endpoints, not this WebSocket.
+     */
+    private handleWebSocket;
+    webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void>;
+    webSocketClose(ws: WebSocket): Promise<void>;
+    private broadcast;
+    private persistMeta;
+    private updatePopularStatus;
+    private calculateDailyViews;
+    /**
+     * Ensure an alarm is scheduled (with deduplication).
+     * Prevents redundant setAlarm() calls which waste resources.
+     */
+    private ensureAlarmScheduled;
+    /**
+     * Trim view_log if it exceeds MAX_VIEW_LOG_ROWS.
+     * Called both by alarm() (hourly) and inline during view recording (every 100 inserts).
+     * This dual approach prevents unbounded growth on viral posts.
+     */
+    private trimViewLogIfNeeded;
+    alarm(): Promise<void>;
+}
+interface Env {
+    DB: D1Database;
+    CACHE_KV: KVNamespace;
+}
+export {};