@weirdfingers/boards 0.1.4

package/dist/index.mjs

@@ -0,0 +1,1096 @@
+// src/auth/context.tsx
+import { createContext, useContext, useEffect, useState, useCallback } from "react";
+import { jsx } from "react/jsx-runtime";
+var AuthContext = createContext(null);
+function AuthProvider({ provider, children }) {
+  const [state, setState] = useState({
+    user: null,
+    status: "loading",
+    signIn: async () => {
+    },
+    signOut: async () => {
+    },
+    getToken: async () => null,
+    refreshToken: async () => null
+  });
+  const [isInitializing, setIsInitializing] = useState(true);
+  const [error, setError] = useState(null);
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+  useEffect(() => {
+    let mounted = true;
+    let unsubscribe = null;
+    const initializeAuth = async () => {
+      try {
+        await provider.initialize();
+        if (!mounted) return;
+        unsubscribe = provider.onAuthStateChange((newState) => {
+          if (mounted) {
+            setState(newState);
+          }
+        });
+        const initialState = await provider.getAuthState();
+        if (mounted) {
+          setState(initialState);
+          setIsInitializing(false);
+        }
+      } catch (err) {
+        if (mounted) {
+          setError(err instanceof Error ? err : new Error("Auth initialization failed"));
+          setIsInitializing(false);
+        }
+      }
+    };
+    initializeAuth();
+    return () => {
+      mounted = false;
+      if (unsubscribe) {
+        unsubscribe();
+      }
+    };
+  }, [provider]);
+  useEffect(() => {
+    return () => {
+      provider.destroy();
+    };
+  }, [provider]);
+  const contextValue = {
+    ...state,
+    isInitializing,
+    error,
+    clearError
+  };
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value: contextValue, children });
+}
+function useAuth() {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error("useAuth must be used within an AuthProvider");
+  }
+  return context;
+}
+function useAuthOptional() {
+  return useContext(AuthContext);
+}
+
+// src/auth/providers/base.ts
+var BaseAuthProvider = class {
+  constructor(config = {}) {
+    this.config = config;
+  }
+  /**
+   * Get the tenant ID from config.
+   */
+  getTenantId() {
+    return this.config.tenantId || "default";
+  }
+};
+
+// src/auth/providers/none.ts
+var NoAuthProvider = class extends BaseAuthProvider {
+  constructor(config = {}) {
+    super(config);
+    this.listeners = [];
+    const nodeEnv = typeof process !== "undefined" ? process.env?.NODE_ENV : "";
+    const isDevelopment = nodeEnv === "development" || nodeEnv === "" || nodeEnv === "test";
+    if (!isDevelopment) {
+      const error = new Error(
+        "NoAuthProvider cannot be used in production environments. Please configure a proper authentication provider (JWT, Supabase, Clerk, etc.)"
+      );
+      console.error("\u{1F6A8} SECURITY ERROR:", error.message);
+      throw error;
+    }
+    this.config = {
+      defaultUserId: "dev-user",
+      defaultEmail: "dev@example.com",
+      defaultDisplayName: "Development User",
+      ...config
+    };
+    this.defaultUser = {
+      id: this.config.defaultUserId,
+      email: this.config.defaultEmail,
+      name: this.config.defaultDisplayName,
+      avatar: void 0,
+      metadata: { provider: "none" },
+      credits: {
+        balance: 1e3,
+        reserved: 0
+      }
+    };
+    this.currentState = {
+      user: this.defaultUser,
+      status: "authenticated",
+      // Always authenticated in no-auth mode
+      signIn: this.signIn.bind(this),
+      signOut: this.signOut.bind(this),
+      getToken: this.getToken.bind(this),
+      refreshToken: this.refreshToken.bind(this)
+    };
+    if (console.warn) {
+      console.warn(
+        "\u{1F6A8} [AUTH] NoAuthProvider is active - authentication is disabled!",
+        {
+          message: "This should ONLY be used in development environments",
+          environment: nodeEnv || "unknown",
+          provider: "none"
+        }
+      );
+    }
+  }
+  async initialize() {
+    this.updateState({ user: this.defaultUser, status: "authenticated" });
+  }
+  async getAuthState() {
+    return this.currentState;
+  }
+  async signIn() {
+    if (console.info) {
+      console.info("[AUTH] SignIn called in no-auth mode - no action taken", {
+        provider: "none",
+        action: "signIn",
+        status: "ignored"
+      });
+    }
+  }
+  async signOut() {
+    if (console.info) {
+      console.info("[AUTH] SignOut called in no-auth mode - no action taken", {
+        provider: "none",
+        action: "signOut",
+        status: "ignored"
+      });
+    }
+  }
+  async getToken() {
+    return "dev-token|no-auth-mode|always-valid";
+  }
+  async refreshToken() {
+    return "dev-token|no-auth-mode|always-valid";
+  }
+  async getUser() {
+    return this.defaultUser;
+  }
+  onAuthStateChange(callback) {
+    callback(this.currentState);
+    this.listeners.push(callback);
+    return () => {
+      const index = this.listeners.indexOf(callback);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  async destroy() {
+    this.listeners = [];
+  }
+  updateState(updates) {
+    this.currentState = { ...this.currentState, ...updates };
+    this.listeners.forEach((listener) => listener(this.currentState));
+  }
+};
+
+// src/config/ApiConfigContext.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ApiConfigContext = createContext2(null);
+function ApiConfigProvider({
+  children,
+  config
+}) {
+  return /* @__PURE__ */ jsx2(ApiConfigContext.Provider, { value: config, children });
+}
+function useApiConfig() {
+  const context = useContext2(ApiConfigContext);
+  if (!context) {
+    throw new Error("useApiConfig must be used within ApiConfigProvider");
+  }
+  return context;
+}
+
+// src/graphql/client.ts
+import {
+  createClient,
+  fetchExchange,
+  cacheExchange,
+  subscriptionExchange,
+  makeOperation
+} from "urql";
+import { authExchange } from "@urql/exchange-auth";
+import { createClient as createWSClient } from "graphql-ws";
+function createGraphQLClient({
+  url,
+  subscriptionUrl,
+  auth,
+  tenantId
+}) {
+  const wsClient = subscriptionUrl ? createWSClient({
+    url: subscriptionUrl,
+    connectionParams: async () => {
+      const token = await auth.getToken();
+      const headers = {};
+      if (token) {
+        headers.Authorization = `Bearer ${token}`;
+      }
+      if (tenantId) {
+        headers["X-Tenant"] = tenantId;
+      }
+      return headers;
+    }
+  }) : null;
+  return createClient({
+    url,
+    exchanges: [
+      cacheExchange,
+      authExchange(async () => {
+        let token = await auth.getToken();
+        return {
+          addAuthToOperation: (operation) => {
+            const headers = {};
+            if (token) {
+              headers.Authorization = `Bearer ${token}`;
+            }
+            if (tenantId) {
+              headers["X-Tenant"] = tenantId;
+            }
+            const fetchOptions = typeof operation.context.fetchOptions === "function" ? operation.context.fetchOptions() : operation.context.fetchOptions || {};
+            return makeOperation(operation.kind, operation, {
+              ...operation.context,
+              fetchOptions: {
+                ...operation.context.fetchOptions,
+                headers: {
+                  ...fetchOptions.headers,
+                  ...headers
+                }
+              }
+            });
+          },
+          didAuthError: (error) => {
+            return error.graphQLErrors.some(
+              (e) => e.extensions?.code === "UNAUTHENTICATED" || e.extensions?.code === "UNAUTHORIZED"
+            );
+          },
+          willAuthError: () => {
+            return false;
+          },
+          refreshAuth: async () => {
+            token = await auth.getToken();
+          }
+        };
+      }),
+      fetchExchange,
+      ...wsClient ? [
+        subscriptionExchange({
+          forwardSubscription: (operation) => ({
+            subscribe: (sink) => ({
+              unsubscribe: wsClient.subscribe(
+                {
+                  query: operation.query || "",
+                  variables: operation.variables
+                },
+                sink
+              )
+            })
+          })
+        })
+      ] : []
+    ]
+  });
+}
+
+// src/graphql/operations.ts
+import { gql } from "urql";
+var USER_FRAGMENT = gql`
+  fragment UserFragment on User {
+    id
+    email
+    displayName
+    avatarUrl
+    createdAt
+  }
+`;
+var BOARD_FRAGMENT = gql`
+  fragment BoardFragment on Board {
+    id
+    tenantId
+    ownerId
+    title
+    description
+    isPublic
+    settings
+    metadata
+    createdAt
+    updatedAt
+    generationCount
+  }
+`;
+var GENERATION_FRAGMENT = gql`
+  fragment GenerationFragment on Generation {
+    id
+    boardId
+    userId
+    generatorName
+    artifactType
+    status
+    progress
+    storageUrl
+    thumbnailUrl
+    inputParams
+    outputMetadata
+    errorMessage
+    createdAt
+    updatedAt
+    completedAt
+  }
+`;
+var GET_CURRENT_USER = gql`
+  ${USER_FRAGMENT}
+  query GetCurrentUser {
+    me {
+      ...UserFragment
+    }
+  }
+`;
+var GET_BOARDS = gql`
+  ${BOARD_FRAGMENT}
+  ${USER_FRAGMENT}
+  query GetBoards($limit: Int, $offset: Int) {
+    myBoards(limit: $limit, offset: $offset) {
+      ...BoardFragment
+      owner {
+        ...UserFragment
+      }
+    }
+  }
+`;
+var GET_BOARD = gql`
+  ${BOARD_FRAGMENT}
+  ${USER_FRAGMENT}
+  ${GENERATION_FRAGMENT}
+  query GetBoard($id: UUID!) {
+    board(id: $id) {
+      ...BoardFragment
+      owner {
+        ...UserFragment
+      }
+      members {
+        id
+        boardId
+        userId
+        role
+        invitedBy
+        joinedAt
+        user {
+          ...UserFragment
+        }
+        inviter {
+          ...UserFragment
+        }
+      }
+      generations(limit: 10) {
+        ...GenerationFragment
+      }
+    }
+  }
+`;
+var GET_GENERATORS = gql`
+  query GetGenerators($artifactType: String) {
+    generators(artifactType: $artifactType) {
+      name
+      description
+      artifactType
+      inputSchema
+    }
+  }
+`;
+var GET_GENERATIONS = gql`
+  ${GENERATION_FRAGMENT}
+  query GetGenerations($boardId: UUID, $limit: Int, $offset: Int) {
+    generations(boardId: $boardId, limit: $limit, offset: $offset) {
+      ...GenerationFragment
+      board {
+        id
+        title
+      }
+      user {
+        ...UserFragment
+      }
+    }
+  }
+`;
+var GET_GENERATION = gql`
+  ${GENERATION_FRAGMENT}
+  query GetGeneration($id: UUID!) {
+    generation(id: $id) {
+      ...GenerationFragment
+      board {
+        ...BoardFragment
+      }
+      user {
+        ...UserFragment
+      }
+    }
+  }
+`;
+var CREATE_BOARD = gql`
+  ${BOARD_FRAGMENT}
+  ${USER_FRAGMENT}
+  mutation CreateBoard($input: CreateBoardInput!) {
+    createBoard(input: $input) {
+      ...BoardFragment
+      owner {
+        ...UserFragment
+      }
+    }
+  }
+`;
+var UPDATE_BOARD = gql`
+  ${BOARD_FRAGMENT}
+  mutation UpdateBoard($id: UUID!, $input: UpdateBoardInput!) {
+    updateBoard(id: $id, input: $input) {
+      ...BoardFragment
+    }
+  }
+`;
+var DELETE_BOARD = gql`
+  mutation DeleteBoard($id: UUID!) {
+    deleteBoard(id: $id) {
+      success
+    }
+  }
+`;
+var ADD_BOARD_MEMBER = gql`
+  mutation AddBoardMember($boardId: UUID!, $email: String!, $role: BoardRole!) {
+    addBoardMember(boardId: $boardId, email: $email, role: $role) {
+      id
+      boardId
+      userId
+      role
+      invitedBy
+      joinedAt
+      user {
+        ...UserFragment
+      }
+    }
+  }
+`;
+var UPDATE_BOARD_MEMBER_ROLE = gql`
+  mutation UpdateBoardMemberRole($id: UUID!, $role: BoardRole!) {
+    updateBoardMemberRole(id: $id, role: $role) {
+      id
+      role
+    }
+  }
+`;
+var REMOVE_BOARD_MEMBER = gql`
+  mutation RemoveBoardMember($id: UUID!) {
+    removeBoardMember(id: $id) {
+      success
+    }
+  }
+`;
+var CREATE_GENERATION = gql`
+  ${GENERATION_FRAGMENT}
+  mutation CreateGeneration($input: CreateGenerationInput!) {
+    createGeneration(input: $input) {
+      ...GenerationFragment
+    }
+  }
+`;
+var CANCEL_GENERATION = gql`
+  mutation CancelGeneration($id: UUID!) {
+    cancelGeneration(id: $id) {
+      id
+      status
+    }
+  }
+`;
+var RETRY_GENERATION = gql`
+  ${GENERATION_FRAGMENT}
+  mutation RetryGeneration($id: UUID!) {
+    retryGeneration(id: $id) {
+      ...GenerationFragment
+    }
+  }
+`;
+var BoardRole = /* @__PURE__ */ ((BoardRole2) => {
+  BoardRole2["VIEWER"] = "VIEWER";
+  BoardRole2["EDITOR"] = "EDITOR";
+  BoardRole2["ADMIN"] = "ADMIN";
+  return BoardRole2;
+})(BoardRole || {});
+var GenerationStatus = /* @__PURE__ */ ((GenerationStatus2) => {
+  GenerationStatus2["PENDING"] = "PENDING";
+  GenerationStatus2["RUNNING"] = "RUNNING";
+  GenerationStatus2["COMPLETED"] = "COMPLETED";
+  GenerationStatus2["FAILED"] = "FAILED";
+  GenerationStatus2["CANCELLED"] = "CANCELLED";
+  return GenerationStatus2;
+})(GenerationStatus || {});
+var ArtifactType = /* @__PURE__ */ ((ArtifactType4) => {
+  ArtifactType4["IMAGE"] = "image";
+  ArtifactType4["VIDEO"] = "video";
+  ArtifactType4["AUDIO"] = "audio";
+  ArtifactType4["TEXT"] = "text";
+  ArtifactType4["LORA"] = "lora";
+  ArtifactType4["MODEL"] = "model";
+  return ArtifactType4;
+})(ArtifactType || {});
+
+// src/hooks/useBoards.ts
+import { useCallback as useCallback2, useMemo, useState as useState2 } from "react";
+import { useQuery, useMutation } from "urql";
+function useBoards(options = {}) {
+  const { limit = 50, offset = 0 } = options;
+  const [searchQuery, setSearchQuery] = useState2("");
+  const [{ data, fetching, error }, reexecuteQuery] = useQuery({
+    query: GET_BOARDS,
+    variables: { limit, offset }
+  });
+  const [, createBoardMutation] = useMutation(CREATE_BOARD);
+  const [, deleteBoardMutation] = useMutation(DELETE_BOARD);
+  const boards = useMemo(() => data?.myBoards || [], [data?.myBoards]);
+  const createBoard = useCallback2(
+    async (input) => {
+      const result = await createBoardMutation({ input });
+      if (result.error) {
+        throw new Error(result.error.message);
+      }
+      if (!result.data?.createBoard) {
+        throw new Error("Failed to create board");
+      }
+      return result.data.createBoard;
+    },
+    [createBoardMutation]
+  );
+  const deleteBoard = useCallback2(
+    async (boardId) => {
+      const result = await deleteBoardMutation({ id: boardId });
+      if (result.error) {
+        throw new Error(result.error.message);
+      }
+      if (!result.data?.deleteBoard?.success) {
+        throw new Error("Failed to delete board");
+      }
+      reexecuteQuery({ requestPolicy: "network-only" });
+    },
+    [deleteBoardMutation, reexecuteQuery]
+  );
+  const searchBoards = useCallback2(
+    async (query) => {
+      setSearchQuery(query);
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(
+            boards.filter(
+              (board) => board.title.toLowerCase().includes(query.toLowerCase()) || board.description?.toLowerCase().includes(query.toLowerCase())
+            )
+          );
+        }, 350);
+      });
+    },
+    [boards]
+  );
+  const refresh = useCallback2(async () => {
+    await reexecuteQuery({ requestPolicy: "network-only" });
+  }, [reexecuteQuery]);
+  return {
+    boards,
+    loading: fetching,
+    error: error ? new Error(error.message) : null,
+    createBoard,
+    deleteBoard,
+    searchBoards,
+    refresh,
+    setSearchQuery,
+    searchQuery
+  };
+}
+
+// src/hooks/useBoard.ts
+import { useCallback as useCallback3, useMemo as useMemo2 } from "react";
+import { useQuery as useQuery2, useMutation as useMutation2 } from "urql";
+function useBoard(boardId) {
+  const { user } = useAuth();
+  const [{ data, fetching, error }, reexecuteQuery] = useQuery2({
+    query: GET_BOARD,
+    variables: { id: boardId },
+    pause: !boardId,
+    requestPolicy: "cache-and-network"
+    // Always fetch fresh data while showing cached data
+  });
+  const [, updateBoardMutation] = useMutation2(UPDATE_BOARD);
+  const [, deleteBoardMutation] = useMutation2(DELETE_BOARD);
+  const [, addMemberMutation] = useMutation2(ADD_BOARD_MEMBER);
+  const [, updateMemberRoleMutation] = useMutation2(UPDATE_BOARD_MEMBER_ROLE);
+  const [, removeMemberMutation] = useMutation2(REMOVE_BOARD_MEMBER);
+  const board = useMemo2(() => data?.board || null, [data?.board]);
+  const members = useMemo2(() => board?.members || [], [board?.members]);
+  const permissions = useMemo2(() => {
+    if (!board || !user) {
+      return {
+        canEdit: false,
+        canDelete: false,
+        canAddMembers: false,
+        canRemoveMembers: false,
+        canGenerate: false,
+        canExport: false
+      };
+    }
+    const isOwner = board.ownerId === user.id;
+    const userMember = members.find(
+      (member) => member.userId === user.id
+    );
+    const userRole = userMember?.role;
+    const isAdmin = userRole === "ADMIN" /* ADMIN */;
+    const isEditor = userRole === "EDITOR" /* EDITOR */ || isAdmin;
+    const isViewer = userRole === "VIEWER" /* VIEWER */ || isEditor;
+    return {
+      canEdit: isOwner || isAdmin || isEditor,
+      canDelete: isOwner,
+      canAddMembers: isOwner || isAdmin,
+      canRemoveMembers: isOwner || isAdmin,
+      canGenerate: isOwner || isAdmin || isEditor,
+      canExport: isViewer
+      // Even viewers can export
+    };
+  }, [board, user, members]);
+  const updateBoard = useCallback3(
+    async (updates) => {
+      if (!boardId) {
+        throw new Error("Board ID is required");
+      }
+      const result = await updateBoardMutation({
+        id: boardId,
+        input: updates
+      });
+      if (result.error) {
+        throw new Error(result.error.message);
+      }
+      if (!result.data?.updateBoard) {
+        throw new Error("Failed to update board");
+      }
+      return result.data.updateBoard;
+    },
+    [boardId, updateBoardMutation]
+  );
+  const deleteBoard = useCallback3(async () => {
+    if (!boardId) {
+      throw new Error("Board ID is required");
+    }
+    const result = await deleteBoardMutation({ id: boardId });
+    if (result.error) {
+      throw new Error(result.error.message);
+    }
+    if (!result.data?.deleteBoard?.success) {
+      throw new Error("Failed to delete board");
+    }
+  }, [boardId, deleteBoardMutation]);
+  const addMember = useCallback3(
+    async (email, role) => {
+      if (!boardId) {
+        throw new Error("Board ID is required");
+      }
+      const result = await addMemberMutation({
+        boardId,
+        email,
+        role
+      });
+      if (result.error) {
+        throw new Error(result.error.message);
+      }
+      if (!result.data?.addBoardMember) {
+        throw new Error("Failed to add member");
+      }
+      reexecuteQuery({ requestPolicy: "network-only" });
+      return result.data.addBoardMember;
+    },
+    [boardId, addMemberMutation, reexecuteQuery]
+  );
+  const removeMember = useCallback3(
+    async (memberId) => {
+      const result = await removeMemberMutation({ id: memberId });
+      if (result.error) {
+        throw new Error(result.error.message);
+      }
+      if (!result.data?.removeBoardMember?.success) {
+        throw new Error("Failed to remove member");
+      }
+      reexecuteQuery({ requestPolicy: "network-only" });
+    },
+    [removeMemberMutation, reexecuteQuery]
+  );
+  const updateMemberRole = useCallback3(
+    async (memberId, role) => {
+      const result = await updateMemberRoleMutation({
+        id: memberId,
+        role
+      });
+      if (result.error) {
+        throw new Error(result.error.message);
+      }
+      if (!result.data?.updateBoardMemberRole) {
+        throw new Error("Failed to update member role");
+      }
+      reexecuteQuery({ requestPolicy: "network-only" });
+      return result.data.updateBoardMemberRole;
+    },
+    [updateMemberRoleMutation, reexecuteQuery]
+  );
+  const generateShareLink = useCallback3(
+    async (_options) => {
+      throw new Error("Share links not implemented yet");
+    },
+    []
+  );
+  const revokeShareLink = useCallback3(
+    async (_linkId) => {
+      throw new Error("Share link revocation not implemented yet");
+    },
+    []
+  );
+  const refresh = useCallback3(async () => {
+    await reexecuteQuery({ requestPolicy: "network-only" });
+  }, [reexecuteQuery]);
+  return {
+    board,
+    members,
+    permissions,
+    loading: fetching,
+    error: error ? new Error(error.message) : null,
+    updateBoard,
+    deleteBoard,
+    refresh,
+    addMember,
+    removeMember,
+    updateMemberRole,
+    generateShareLink,
+    revokeShareLink
+  };
+}
+
+// src/hooks/useGeneration.ts
+import { useCallback as useCallback4, useState as useState3, useEffect as useEffect2, useRef } from "react";
+import { fetchEventSource } from "@microsoft/fetch-event-source";
+import { useMutation as useMutation3 } from "urql";
+function useGeneration() {
+  const [progress, setProgress] = useState3(null);
+  const [result, setResult] = useState3(null);
+  const [error, setError] = useState3(null);
+  const [isGenerating, setIsGenerating] = useState3(false);
+  const [history, setHistory] = useState3([]);
+  const { apiUrl } = useApiConfig();
+  const auth = useAuth();
+  const abortControllers = useRef(/* @__PURE__ */ new Map());
+  const [, createGenerationMutation] = useMutation3(CREATE_GENERATION);
+  const [, cancelGenerationMutation] = useMutation3(CANCEL_GENERATION);
+  const [, retryGenerationMutation] = useMutation3(RETRY_GENERATION);
+  useEffect2(() => {
+    return () => {
+      abortControllers.current.forEach((controller) => {
+        controller.abort();
+      });
+      abortControllers.current.clear();
+    };
+  }, []);
+  const connectToSSE = useCallback4(
+    async (jobId) => {
+      const existingController = abortControllers.current.get(jobId);
+      if (existingController) {
+        existingController.abort();
+      }
+      const abortController = new AbortController();
+      abortControllers.current.set(jobId, abortController);
+      const token = await auth.getToken();
+      const headers = {
+        Accept: "text/event-stream"
+      };
+      if (token) {
+        headers.Authorization = `Bearer ${token}`;
+      }
+      const sseUrl = `${apiUrl}/api/sse/generations/${jobId}/progress`;
+      console.log("SSE: Connecting to", sseUrl, "with headers:", headers);
+      try {
+        await fetchEventSource(sseUrl, {
+          headers,
+          signal: abortController.signal,
+          async onopen(response) {
+            console.log(
+              "SSE: Connection opened",
+              response.status,
+              response.statusText
+            );
+            if (response.ok) {
+              console.log("SSE: Connection successful");
+            } else {
+              console.error("SSE: Connection failed", response.status);
+              throw new Error(`SSE connection failed: ${response.statusText}`);
+            }
+          },
+          onmessage(event) {
+            console.log("SSE: Raw event received:", event);
+            if (!event.data || event.data.trim() === "") {
+              console.log("SSE: Skipping empty message");
+              return;
+            }
+            try {
+              const progressData = JSON.parse(event.data);
+              console.log("SSE: progress data received:", progressData);
+              setProgress(progressData);
+              if (progressData.status === "completed" || progressData.status === "failed" || progressData.status === "cancelled") {
+                setIsGenerating(false);
+                if (progressData.status === "completed") {
+                  const mockResult = {
+                    id: progressData.jobId,
+                    jobId: progressData.jobId,
+                    boardId: "",
+                    // Would be filled from the original request
+                    request: {},
+                    artifacts: [],
+                    credits: { cost: 0, balanceBefore: 0, balance: 0 },
+                    performance: {
+                      queueTime: 0,
+                      processingTime: 0,
+                      totalTime: 0
+                    },
+                    createdAt: /* @__PURE__ */ new Date()
+                  };
+                  setResult(mockResult);
+                  setHistory((prev) => [...prev, mockResult]);
+                } else if (progressData.status === "failed") {
+                  setError(new Error("Generation failed"));
+                }
+                abortController.abort();
+                abortControllers.current.delete(jobId);
+              }
+            } catch (err) {
+              console.error("Failed to parse SSE message:", err);
+              setError(new Error("Failed to parse progress update"));
+              setIsGenerating(false);
+              abortController.abort();
+              abortControllers.current.delete(jobId);
+            }
+          },
+          onerror(err) {
+            console.error("SSE connection error:", err);
+            console.error("SSE error details:", {
+              message: err instanceof Error ? err.message : String(err),
+              jobId,
+              url: sseUrl
+            });
+            setError(new Error("Lost connection to generation progress"));
+            setIsGenerating(false);
+            abortController.abort();
+            abortControllers.current.delete(jobId);
+            throw err;
+          },
+          openWhenHidden: true
+          // Keep connection open when tab is hidden
+        });
+      } catch (err) {
+        if (abortController.signal.aborted) {
+          console.log("SSE connection aborted for job:", jobId);
+        } else {
+          console.error("SSE connection failed:", err);
+        }
+      }
+    },
+    [apiUrl, auth]
+  );
+  const submit = useCallback4(
+    async (request) => {
+      setError(null);
+      setProgress(null);
+      setResult(null);
+      setIsGenerating(true);
+      const input = {
+        boardId: request.boardId,
+        generatorName: request.model,
+        artifactType: request.artifactType,
+        inputParams: {
+          ...request.inputs,
+          ...request.options
+        }
+      };
+      let lastError = null;
+      const maxRetries = 2;
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+          const result2 = await createGenerationMutation({ input });
+          if (result2.error) {
+            throw new Error(result2.error.message);
+          }
+          if (!result2.data?.createGeneration) {
+            throw new Error("Failed to create generation");
+          }
+          const jobId = result2.data.createGeneration.id;
+          connectToSSE(jobId);
+          setIsGenerating(false);
+          return jobId;
+        } catch (err) {
+          lastError = err instanceof Error ? err : new Error("Failed to submit generation");
+          if (lastError.message.includes("insufficient credits") || lastError.message.includes("validation") || lastError.message.includes("unauthorized") || lastError.message.includes("forbidden")) {
+            setError(lastError);
+            setIsGenerating(false);
+            throw lastError;
+          }
+          if (attempt === maxRetries) {
+            setError(lastError);
+            setIsGenerating(false);
+            throw lastError;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 1e3 * attempt));
+        }
+      }
+      const finalError = lastError || new Error("Failed to submit generation after retries");
+      setError(finalError);
+      setIsGenerating(false);
+      throw finalError;
+    },
+    [createGenerationMutation, connectToSSE]
+  );
+  const cancel = useCallback4(
+    async (jobId) => {
+      try {
+        const result2 = await cancelGenerationMutation({ id: jobId });
+        if (result2.error) {
+          throw new Error(result2.error.message);
+        }
+        const controller = abortControllers.current.get(jobId);
+        if (controller) {
+          controller.abort();
+          abortControllers.current.delete(jobId);
+        }
+        setIsGenerating(false);
+        setProgress((prev) => prev ? { ...prev, status: "cancelled" } : null);
+      } catch (err) {
+        setError(
+          err instanceof Error ? err : new Error("Failed to cancel generation")
+        );
+      }
+    },
+    [cancelGenerationMutation]
+  );
+  const retry = useCallback4(
+    async (jobId) => {
+      try {
+        setError(null);
+        setIsGenerating(true);
+        const result2 = await retryGenerationMutation({ id: jobId });
+        if (result2.error) {
+          throw new Error(result2.error.message);
+        }
+        if (!result2.data?.retryGeneration) {
+          throw new Error("Failed to retry generation");
+        }
+        const newJobId = result2.data.retryGeneration.id;
+        connectToSSE(newJobId);
+      } catch (err) {
+        setError(
+          err instanceof Error ? err : new Error("Failed to retry generation")
+        );
+        setIsGenerating(false);
+      }
+    },
+    [retryGenerationMutation, connectToSSE]
+  );
+  const clearHistory = useCallback4(() => {
+    setHistory([]);
+  }, []);
+  return {
+    progress,
+    result,
+    error,
+    isGenerating,
+    submit,
+    cancel,
+    retry,
+    history,
+    clearHistory
+  };
+}
+
+// src/hooks/useGenerators.ts
+import { useMemo as useMemo3 } from "react";
+import { useQuery as useQuery3 } from "urql";
+function useGenerators(options = {}) {
+  const { artifactType } = options;
+  const [{ data, fetching, error }] = useQuery3({
+    query: GET_GENERATORS,
+    variables: artifactType ? { artifactType } : {}
+  });
+  const generators = useMemo3(() => data?.generators || [], [data?.generators]);
+  return {
+    generators,
+    loading: fetching,
+    error: error ? new Error(error.message) : null
+  };
+}
+
+// src/providers/BoardsProvider.tsx
+import { Provider as UrqlProvider } from "urql";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function BoardsProvider({
+  children,
+  apiUrl,
+  graphqlUrl,
+  subscriptionUrl,
+  authProvider,
+  tenantId
+}) {
+  const resolvedGraphqlUrl = graphqlUrl || `${apiUrl}/graphql`;
+  const apiConfig = {
+    apiUrl,
+    graphqlUrl: resolvedGraphqlUrl,
+    subscriptionUrl
+  };
+  const client = createGraphQLClient({
+    url: resolvedGraphqlUrl,
+    subscriptionUrl,
+    auth: {
+      getToken: () => authProvider.getAuthState().then((state) => state.getToken())
+    },
+    tenantId
+  });
+  return /* @__PURE__ */ jsx3(AuthProvider, { provider: authProvider, children: /* @__PURE__ */ jsx3(ApiConfigProvider, { config: apiConfig, children: /* @__PURE__ */ jsx3(UrqlProvider, { value: client, children }) }) });
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  ADD_BOARD_MEMBER,
+  ArtifactType,
+  AuthProvider,
+  BOARD_FRAGMENT,
+  BaseAuthProvider,
+  BoardRole,
+  BoardsProvider,
+  CANCEL_GENERATION,
+  CREATE_BOARD,
+  CREATE_GENERATION,
+  DELETE_BOARD,
+  GENERATION_FRAGMENT,
+  GET_BOARD,
+  GET_BOARDS,
+  GET_CURRENT_USER,
+  GET_GENERATION,
+  GET_GENERATIONS,
+  GET_GENERATORS,
+  GenerationStatus,
+  NoAuthProvider,
+  REMOVE_BOARD_MEMBER,
+  RETRY_GENERATION,
+  UPDATE_BOARD,
+  UPDATE_BOARD_MEMBER_ROLE,
+  USER_FRAGMENT,
+  VERSION,
+  createGraphQLClient,
+  useApiConfig,
+  useAuth,
+  useAuthOptional,
+  useBoard,
+  useBoards,
+  useGeneration,
+  useGenerators
+};
+//# sourceMappingURL=index.mjs.map