@mevdragon/vidfarm-devcli 0.2.8 → 0.2.9

package/dist/src/domain.js

@@ -1 +1 @@
-export {};
+export const CUSTOMER_PLAN_TIERS = ["starter", "standard", "agency"];

package/dist/src/editor-chat-history.js

@@ -0,0 +1,72 @@
+const MAX_CHAT_PAYLOAD_STRING_LENGTH = 1200;
+const MAX_CHAT_PAYLOAD_ARRAY_ITEMS = 24;
+const MAX_CHAT_PAYLOAD_OBJECT_KEYS = 80;
+const DATA_URL_PREFIX_REGEX = /^data:([^;,]+)[^,]*,/i;
+function summarizeLargeString(value) {
+    const dataUrlMatch = DATA_URL_PREFIX_REGEX.exec(value);
+    if (dataUrlMatch) {
+        return `[${dataUrlMatch[1]} data URL omitted, ${value.length.toLocaleString()} chars]`;
+    }
+    if (value.length > MAX_CHAT_PAYLOAD_STRING_LENGTH) {
+        return `${value.slice(0, MAX_CHAT_PAYLOAD_STRING_LENGTH)}... [truncated ${value.length.toLocaleString()} chars]`;
+    }
+    return value;
+}
+export function sanitizeChatPayload(value, depth = 0) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === "string") {
+        return summarizeLargeString(value);
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (typeof value === "function" || typeof value === "symbol") {
+        return undefined;
+    }
+    if (depth >= 8) {
+        return "[nested payload omitted]";
+    }
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, MAX_CHAT_PAYLOAD_ARRAY_ITEMS)
+            .map((entry) => sanitizeChatPayload(entry, depth + 1));
+        if (value.length > MAX_CHAT_PAYLOAD_ARRAY_ITEMS) {
+            items.push(`[${value.length - MAX_CHAT_PAYLOAD_ARRAY_ITEMS} more items omitted]`);
+        }
+        return items;
+    }
+    if (typeof value === "object") {
+        const output = {};
+        const entries = Object.entries(value);
+        for (const [key, entry] of entries.slice(0, MAX_CHAT_PAYLOAD_OBJECT_KEYS)) {
+            const sanitized = sanitizeChatPayload(entry, depth + 1);
+            if (sanitized !== undefined) {
+                output[key] = sanitized;
+            }
+        }
+        if (entries.length > MAX_CHAT_PAYLOAD_OBJECT_KEYS) {
+            output.__omitted_keys = entries.length - MAX_CHAT_PAYLOAD_OBJECT_KEYS;
+        }
+        return output;
+    }
+    return String(value);
+}
+export function sanitizeHttpExchange(exchange) {
+    return {
+        ...exchange,
+        request: {
+            ...exchange.request,
+            body: sanitizeChatPayload(exchange.request.body)
+        },
+        result: {
+            ...exchange.result,
+            body: sanitizeChatPayload(exchange.result.body),
+            error: exchange.result.error ? summarizeLargeString(exchange.result.error) : exchange.result.error
+        }
+    };
+}

package/dist/src/editor-chat.js

@@ -0,0 +1,202 @@
+export const EDITOR_CHAT_PROVIDER_PRIORITY = [
+    "openai",
+    "gemini",
+    "openrouter",
+    "perplexity"
+];
+export function defaultEditorChatModel(provider) {
+    switch (provider) {
+        case "openai":
+            return "gpt-4.1-mini";
+        case "gemini":
+            return "gemini-2.5-flash";
+        case "openrouter":
+            return "qwen/qwen3.6-flash";
+        case "perplexity":
+            return "sonar";
+    }
+}
+export function buildTemplateEditorChatSystemPrompt(input) {
+    const routeLines = input.docsRoutes
+        .map((route) => `- ${route.method} ${route.path}: ${route.summary}`)
+        .join("\n");
+    return [
+        "You are Vidfarm's template editor copilot.",
+        "Help the user understand and operate this template through its existing template and primitive REST surface.",
+        "Be concrete. Prefer exact route names, payload fields, and tracer usage over generic advice.",
+        "If you mention a route or operation, only mention routes that exist in the provided template context.",
+        "If attachments are present, reason about them as user-supplied reference assets for template operations or primitive image edits.",
+        "When the user wants to run the template, prefer doing it via REST calls instead of only describing what to do.",
+        "Execute REST calls sequentially. Make one API call, inspect the response, then decide the next step.",
+        "When chaining one operation's output into another operation, copy the exact nested payload returned by the previous response, such as result.renderVideoInput. Do not reconstruct, normalize, shorten, expand, or add job IDs to media URLs, S3 keys, durations, or slide arrays.",
+        "Never claim that you called a REST route, started rendering, concatenated slides, or created a job unless the http_request tool returned that result in this response.",
+        "Never invent or infer a job_id. Only mention a job_id that appears verbatim in an http_request tool response body or a job status response.",
+        "If you need to make an API call, call the http_request tool; do not write prose such as 'Here is the http_request call' unless the tool call has actually completed and the UI will show its exchange.",
+        "Do not fan out multiple operation calls, repeated polling bursts, or speculative retries in parallel.",
+        "Prefer the minimum number of API calls needed to complete the user's request, but if the user asks for N distinct generated outputs, make N sequential POST operation calls.",
+        "For template operations that generate one card, post, render, or asset per job, do not collapse a counted request into one job unless the user explicitly asks for one combined job.",
+        "Treat tracers as the work-organization primitive. The current chat thread's tracers are the source of truth for API context.",
+        "Reuse the default request tracer for the current chat thread unless the user explicitly asks for a separate parallel stream.",
+        "When you start or revise work with a POST template operation or primitive route, include a tracer in the JSON body.",
+        "If the user asks for each output to have its own tracer, use a different readable tracer base for each POST request.",
+        "If the user asks for each output to have its own chat thread, call frontend_action with action=create_thread for each tracer before or alongside the corresponding POST request.",
+        "If multiple tracers are available, mention which tracer you are using when it matters.",
+        "If the user asks to add, remove, switch tracers, or create a separate chat thread for a tracer, use the frontend_action tool so the page state updates directly.",
+        "If polling a job, poll gently. Prefer about every 30 seconds rather than rapid repeated checks.",
+        "If the customer already has at least one saved provider key that should work for this template, do not ask them to provide another API key.",
+        "If provider selection is unspecified, choose a supported saved provider automatically, update template config first when needed, and then continue.",
+        "If a run fails because the current template config points at an unavailable provider, switch config to a saved supported provider and retry instead of asking the user to choose.",
+        "Prefer primitive image routes when the user wants a reusable asset edit or render that is not specific to one template operation.",
+        "Use the word create for template experimentation and drafting. Use the word approve only for converting a finished output into a schedule-ready post.",
+        "When the user asks to approve, package, share, preview, or make a finished output schedule-ready, approve a post with POST /api/v1/approved/posts using only title, caption, pinned_comment when useful, media URLs, and the current tracer.",
+        "If the finished output is a rendered slideshow video, include both the MP4 and the finished slide frame image URLs in the post media array so the post page can expose Video and Slides versions. Prefer role=\"primary\" for the video and role=\"slide\" for each finished slide image.",
+        "When approving a post from chat, include tracer in the JSON body. Do not send view_password unless the user explicitly asked for a different preview password; the server defaults it to password123.",
+        "After approving a post, return the post.share_url as a Markdown link so the user can open the preview page in a new tab.",
+        "Do not claim a post was approved unless POST /api/v1/approved/posts returned a post_id and share_url in the current response.",
+        "When the user asks to schedule an approved post, use POST /api/v1/approved/posts/:postId/schedules after you know the approved post id, destination channel id, and scheduled_at ISO timestamp.",
+        "For scheduling, resolve the user's named channel against the cached scheduling channels. Use destination_type=\"email\" for email pseudo-channels and destination_type=\"flockposter\" for FlockPoster/social channels.",
+        "If the channel name or date/time is ambiguous, ask a concise clarification question instead of guessing. If the user gives a local date/time without a timezone, ask for timezone unless the timezone is already explicit in the conversation.",
+        "Do not claim a post was scheduled unless POST /api/v1/approved/posts/:postId/schedules returned a schedule object in the current response.",
+        "",
+        `Template title: ${input.templateTitle}`,
+        `Template id: ${input.templateId}`,
+        `Template slug: ${input.templateSlug}`,
+        `Editor page: ${input.page}`,
+        `Tracer id: ${input.tracerId ?? "none"}`,
+        `Available tracers: ${input.tracers.length ? input.tracers.join(", ") : "none"}`,
+        `Default request tracer: ${input.defaultRequestTracer ?? input.activeTracer ?? input.tracerId ?? "none"}`,
+        `Template description: ${input.templateDescription}`,
+        "",
+        "Documented REST routes:",
+        routeLines || "- No routes documented."
+    ].join("\n");
+}
+export function buildEditorChatSystemInstruction(input) {
+    const sections = [];
+    if (input.cachedContext?.directorSkill?.trim()) {
+        sections.push(`Director skill context:\n\n${input.cachedContext.directorSkill.trim()}`);
+    }
+    if (input.cachedContext?.templateSkill?.trim()) {
+        sections.push(`Template skill context:\n\n${input.cachedContext.templateSkill.trim()}`);
+    }
+    sections.push([
+        `Saved providers for this customer: ${input.cachedContext?.availableProviders?.length ? input.cachedContext.availableProviders.join(", ") : "none"}.`,
+        `Current template config: ${input.cachedContext?.currentTemplateConfig ? JSON.stringify(input.cachedContext.currentTemplateConfig, null, 2) : "none saved"}.`,
+        `Cached scheduling channels${input.cachedContext?.scheduleChannelsUpdatedAt ? ` as of ${input.cachedContext.scheduleChannelsUpdatedAt}` : ""}: ${input.cachedContext?.scheduleChannels?.length ? JSON.stringify(input.cachedContext.scheduleChannels, null, 2) : "none cached"}.`,
+        `Selected library posts${input.cachedContext?.selectedPostsUpdatedAt ? ` as of ${input.cachedContext.selectedPostsUpdatedAt}` : ""}: ${input.cachedContext?.selectedPosts?.length ? JSON.stringify(input.cachedContext.selectedPosts, null, 2) : "none selected"}.`,
+        "Operational rule: if the user asks to create or run something and saved providers exist, pick one automatically and call the template config route when needed before running the operation.",
+        "Operational rule: use REST routes sequentially and avoid parallel route bursts or aggressive polling loops.",
+        "Operational rule: organize work with tracers and keep each POST run attached to the correct tracer.",
+        "Operational rule: if the user asks to schedule a post and cached scheduling channels are missing, ask them to connect or refresh channels before scheduling. If channels are present, match by id, name/title, handle, platform, or email label.",
+        "Operational rule: when selected library posts are present and the user says 'these posts' or similar, schedule exactly those post IDs unless the user narrows the set.",
+        "Tool honesty rule: job IDs, render status, concat success, and HTTP call claims must come from actual http_request tool results in the current response, never from memory or guesswork."
+    ].join("\n"));
+    if (input.template) {
+        sections.push(buildTemplateEditorChatSystemPrompt(input.template));
+    }
+    if (input.currentDateTime?.trim()) {
+        sections.push([
+            "Current datetime for scheduling:",
+            input.currentDateTime.trim(),
+            "Use this timestamp to interpret relative dates like today, tomorrow, and next Friday."
+        ].join("\n"));
+    }
+    return sections.filter((entry) => entry.trim().length > 0).join("\n\n");
+}
+export function formatEditorChatCurrentDateTime(clientContext) {
+    const lines = [];
+    const iso = clientContext?.currentDateTime?.trim();
+    const local = clientContext?.localDateTime?.trim();
+    const timeZone = clientContext?.timeZone?.trim();
+    if (iso) {
+        lines.push(`ISO timestamp: ${iso}`);
+    }
+    if (local) {
+        lines.push(`Browser local datetime: ${local}`);
+    }
+    if (timeZone) {
+        lines.push(`Browser timezone: ${timeZone}`);
+    }
+    return lines.join("\n");
+}
+function tryParseUrl(value) {
+    try {
+        return new URL(value);
+    }
+    catch {
+        return null;
+    }
+}
+function decodeDataUrl(value) {
+    const match = /^data:([^;,]+)?(?:;charset=[^;,]+)?;base64,(.+)$/i.exec(value);
+    if (!match) {
+        return null;
+    }
+    const mediaType = match[1]?.trim() || "application/octet-stream";
+    const data = Buffer.from(match[2], "base64");
+    return { mediaType, data };
+}
+export function toEditorChatModelMessages(messages) {
+    const result = [];
+    for (const entry of messages) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const role = entry.role;
+        if (role !== "user" && role !== "assistant" && role !== "system" && role !== "tool") {
+            continue;
+        }
+        if (role === "system") {
+            continue;
+        }
+        const content = Array.isArray(entry.content)
+            ? entry.content
+            : [];
+        if (role === "user") {
+            const parts = [];
+            for (const part of content) {
+                if (part.type === "text" && typeof part.text === "string") {
+                    parts.push({ type: "text", text: part.text });
+                    continue;
+                }
+                if (part.type !== "file" || typeof part.data !== "string") {
+                    continue;
+                }
+                const mediaType = typeof part.mediaType === "string" && part.mediaType.trim()
+                    ? part.mediaType.trim()
+                    : "application/octet-stream";
+                const decoded = decodeDataUrl(part.data);
+                if (decoded) {
+                    parts.push({
+                        type: "file",
+                        data: decoded.data,
+                        mediaType: mediaType || decoded.mediaType
+                    });
+                    continue;
+                }
+                const url = tryParseUrl(part.data);
+                if (!url) {
+                    continue;
+                }
+                parts.push({
+                    type: "file",
+                    data: url,
+                    mediaType
+                });
+            }
+            result.push({ role: "user", content: parts });
+            continue;
+        }
+        if (role === "assistant") {
+            const parts = [];
+            for (const part of content) {
+                if (part.type === "text" && typeof part.text === "string") {
+                    parts.push({ type: "text", text: part.text });
+                }
+            }
+            result.push({ role: "assistant", content: parts });
+            continue;
+        }
+    }
+    return result;
+}

package/dist/src/frontend/flockposter-cache-store.js

@@ -0,0 +1,116 @@
+import { createStore } from "zustand/vanilla";
+export const FLOCKPOSTER_CACHE_STORAGE_KEY = "vidfarm:flockposter-cache:v1";
+const PUBLIC_SCOPE = "public";
+const emptySnapshot = {
+    channels: [],
+    posts: [],
+    channelsUpdatedAt: null,
+    calendarUpdatedAt: null,
+    calendarRangeStart: null,
+    calendarRangeEnd: null
+};
+export function getFlockPosterCacheStorageKey(userId) {
+    return `${FLOCKPOSTER_CACHE_STORAGE_KEY}_${userId?.trim() || PUBLIC_SCOPE}`;
+}
+export function readFlockPosterCacheSnapshot(userId) {
+    if (typeof window === "undefined") {
+        return emptySnapshot;
+    }
+    try {
+        const raw = window.localStorage.getItem(getFlockPosterCacheStorageKey(userId));
+        if (!raw) {
+            return emptySnapshot;
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return emptySnapshot;
+        }
+        return {
+            channels: Array.isArray(parsed.channels) ? parsed.channels : [],
+            posts: Array.isArray(parsed.posts) ? parsed.posts : [],
+            channelsUpdatedAt: typeof parsed.channelsUpdatedAt === "string" ? parsed.channelsUpdatedAt : null,
+            calendarUpdatedAt: typeof parsed.calendarUpdatedAt === "string" ? parsed.calendarUpdatedAt : null,
+            calendarRangeStart: typeof parsed.calendarRangeStart === "string" ? parsed.calendarRangeStart : null,
+            calendarRangeEnd: typeof parsed.calendarRangeEnd === "string" ? parsed.calendarRangeEnd : null
+        };
+    }
+    catch {
+        return emptySnapshot;
+    }
+}
+function writeFlockPosterCacheSnapshot(snapshot, userId) {
+    if (typeof window === "undefined") {
+        return;
+    }
+    try {
+        window.localStorage.setItem(getFlockPosterCacheStorageKey(userId), JSON.stringify(snapshot));
+    }
+    catch {
+        // Ignore storage failures and keep in-memory state only.
+    }
+}
+export function createFlockPosterCacheStore(userId) {
+    const initial = readFlockPosterCacheSnapshot(userId);
+    return createStore((set, get) => ({
+        ...initial,
+        setChannelsData: (channels) => {
+            const next = {
+                ...get(),
+                channels,
+                channelsUpdatedAt: new Date().toISOString()
+            };
+            writeFlockPosterCacheSnapshot(next, userId);
+            set(next);
+        },
+        setCalendarData: (input) => {
+            const current = get();
+            const mergedChannels = dedupeChannels([...current.channels, ...input.channels]);
+            const mergedPosts = input.replaceRange
+                ? mergePostsForRange(current.posts, input.posts, input.rangeStart, input.rangeEnd)
+                : dedupePosts([...current.posts, ...input.posts]);
+            const next = {
+                ...current,
+                channels: mergedChannels,
+                posts: mergedPosts,
+                channelsUpdatedAt: new Date().toISOString(),
+                calendarUpdatedAt: new Date().toISOString(),
+                calendarRangeStart: expandRangeStart(current.calendarRangeStart, input.rangeStart),
+                calendarRangeEnd: expandRangeEnd(current.calendarRangeEnd, input.rangeEnd)
+            };
+            writeFlockPosterCacheSnapshot(next, userId);
+            set(next);
+        }
+    }));
+}
+function dedupeChannels(channels) {
+    return [...new Map(channels.map((channel) => [channel.id, channel])).values()];
+}
+function dedupePosts(posts) {
+    return [...new Map(posts.map((post) => [post.id, post])).values()];
+}
+function mergePostsForRange(currentPosts, nextPosts, rangeStart, rangeEnd) {
+    const startTime = Date.parse(rangeStart);
+    const endTime = Date.parse(rangeEnd);
+    if (Number.isNaN(startTime) || Number.isNaN(endTime)) {
+        return dedupePosts([...currentPosts, ...nextPosts]);
+    }
+    return dedupePosts([
+        ...currentPosts.filter((post) => {
+            const scheduledTime = Date.parse(post.scheduledAt);
+            return Number.isNaN(scheduledTime) || scheduledTime < startTime || scheduledTime > endTime;
+        }),
+        ...nextPosts
+    ]);
+}
+function expandRangeStart(current, next) {
+    if (!current) {
+        return next;
+    }
+    return Date.parse(next) < Date.parse(current) ? next : current;
+}
+function expandRangeEnd(current, next) {
+    if (!current) {
+        return next;
+    }
+    return Date.parse(next) > Date.parse(current) ? next : current;
+}

package/dist/src/frontend/homepage-client.js

@@ -0,0 +1,114 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { hydrateRoot } from "react-dom/client";
+import { useStore } from "zustand";
+import { HomepageShell } from "./homepage-view.js";
+import { createHomepageStore } from "./homepage-store.js";
+const bookmarkStorageKey = "vidfarm:discover-bookmarks:v1";
+const publicBookmarkScope = "public";
+function readBoot() {
+    const element = document.getElementById("homepage-boot");
+    if (!element?.textContent) {
+        return {
+            templates: [],
+            account: { isLoggedIn: false },
+            loadEndpoint: "/discover/feed",
+            skillEndpointPrefix: "/discover/skills/"
+        };
+    }
+    return JSON.parse(element.textContent);
+}
+function resolveBookmarkStorageKey(userId) {
+    return `${bookmarkStorageKey}_${userId?.trim() || publicBookmarkScope}`;
+}
+function readBookmarks(userId) {
+    try {
+        const raw = window.localStorage.getItem(resolveBookmarkStorageKey(userId));
+        if (!raw) {
+            return new Set();
+        }
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return new Set();
+        }
+        return new Set(parsed.filter((value) => typeof value === "string"));
+    }
+    catch {
+        return new Set();
+    }
+}
+function writeBookmarks(bookmarks, userId) {
+    try {
+        window.localStorage.setItem(resolveBookmarkStorageKey(userId), JSON.stringify(Array.from(bookmarks)));
+    }
+    catch {
+        // Ignore storage failures and keep in-memory state.
+    }
+}
+function filterTemplates(input) {
+    const query = input.searchQuery.trim().toLowerCase();
+    return input.templates.filter((template) => {
+        const matchesSearch = !query || `${template.templateId} ${template.title} ${template.slugId}`.toLowerCase().includes(query);
+        const matchesBookmarks = !input.bookmarksOnly || input.bookmarks.has(template.templateId);
+        return matchesSearch && matchesBookmarks;
+    });
+}
+function HomepageClientApp({ boot }) {
+    const store = useMemo(() => createHomepageStore(boot), [boot]);
+    const templates = useStore(store, (state) => state.templates);
+    const searchQuery = useStore(store, (state) => state.searchQuery);
+    const bookmarksOnly = useStore(store, (state) => state.bookmarksOnly);
+    const bookmarks = useStore(store, (state) => state.bookmarks);
+    const loading = useStore(store, (state) => state.loading);
+    const error = useStore(store, (state) => state.error);
+    const [bookmarksReady, setBookmarksReady] = useState(false);
+    const visibleTemplates = useMemo(() => filterTemplates({ templates, searchQuery, bookmarksOnly, bookmarks }), [templates, searchQuery, bookmarksOnly, bookmarks]);
+    useEffect(() => {
+        store.getState().setBookmarks(readBookmarks(boot.account.userId));
+        setBookmarksReady(true);
+    }, [boot.account.userId, store]);
+    useEffect(() => {
+        if (!bookmarksReady) {
+            return;
+        }
+        writeBookmarks(bookmarks, boot.account.userId);
+    }, [boot.account.userId, bookmarks, bookmarksReady]);
+    useEffect(() => {
+        if (boot.templates.length > 0) {
+            return;
+        }
+        let cancelled = false;
+        store.getState().setLoading(true);
+        void (async () => {
+            try {
+                const response = await fetch(boot.loadEndpoint, {
+                    credentials: "same-origin",
+                    headers: { Accept: "application/json" }
+                });
+                const payload = await response.json().catch(() => ({}));
+                if (!response.ok) {
+                    throw new Error(typeof payload.error === "string" && payload.error ? payload.error : "Unable to load formats.");
+                }
+                if (cancelled) {
+                    return;
+                }
+                store.getState().setTemplates(Array.isArray(payload.templates) ? payload.templates : []);
+            }
+            catch (fetchError) {
+                if (cancelled) {
+                    return;
+                }
+                store.getState().setError(fetchError instanceof Error ? fetchError.message : "Unable to load formats.");
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [boot.loadEndpoint, boot.templates.length, store]);
+    return (_jsx(HomepageShell, { account: boot.account, templates: templates, visibleTemplates: visibleTemplates, searchQuery: searchQuery, bookmarksOnly: bookmarksOnly, bookmarks: bookmarks, loading: loading, error: error, skillEndpointPrefix: boot.skillEndpointPrefix, onSearchQueryChange: (value) => store.getState().setSearchQuery(value), onBookmarksOnlyChange: (value) => store.getState().setBookmarksOnly(value), onToggleBookmark: (templateId) => store.getState().toggleBookmark(templateId) }));
+}
+const boot = readBoot();
+const root = document.getElementById("homepage-root");
+if (root) {
+    hydrateRoot(root, _jsx(HomepageClientApp, { boot: boot }));
+}

package/dist/src/frontend/homepage-shared.js

@@ -0,0 +1,3 @@
+export function isVideoPreview(url) {
+    return Boolean(url && /\.(mp4|webm|ogg|mov)(\?|#|$)/i.test(url));
+}

package/dist/src/frontend/homepage-store.js

@@ -0,0 +1,27 @@
+import { createStore } from "zustand/vanilla";
+export function createHomepageStore(boot) {
+    return createStore((set) => ({
+        templates: boot.templates,
+        searchQuery: "",
+        bookmarksOnly: false,
+        bookmarks: new Set(),
+        loading: boot.templates.length === 0,
+        error: null,
+        setTemplates: (templates) => set({ templates, loading: false, error: null }),
+        setSearchQuery: (searchQuery) => set({ searchQuery }),
+        setBookmarksOnly: (bookmarksOnly) => set({ bookmarksOnly }),
+        setBookmarks: (bookmarks) => set({ bookmarks: new Set(bookmarks) }),
+        toggleBookmark: (templateId) => set((state) => {
+            const next = new Set(state.bookmarks);
+            if (next.has(templateId)) {
+                next.delete(templateId);
+            }
+            else {
+                next.add(templateId);
+            }
+            return { bookmarks: next };
+        }),
+        setLoading: (loading) => set({ loading }),
+        setError: (error) => set({ error, loading: false })
+    }));
+}