@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0

package/dist/chunk-WGBCRNMB.js

@@ -0,0 +1,1817 @@
+import {
+  deleteDatabaseByDataDir
+} from "./chunk-3LFMIVJM.js";
+import {
+  DORMANT_BIOSIGNAL_BRIDGES,
+  DORMANT_BIOSIGNAL_PROVIDERS,
+  PGLiteConnectionPool,
+  getCurrentDataDir,
+  getDB,
+  getDataDirForScope,
+  isBiosignalBridgeId,
+  isBiosignalProviderId,
+  isDatabaseReady,
+  setDbScope,
+  shutdownPool
+} from "./chunk-AFDUOYHD.js";
+
+// ../../lib/pglite/utils.ts
+var __warnedDbNotReady = false;
+async function safeDbOperation(operation, fallback) {
+  if (!isDatabaseReady()) {
+    if (process.env.NEXT_PUBLIC_DEBUG_DB === "true" && !__warnedDbNotReady) {
+      console.warn("Database not ready, using fallback value");
+      __warnedDbNotReady = true;
+    }
+    return fallback;
+  }
+  try {
+    return await operation();
+  } catch (error) {
+    console.error("Database operation failed:", error);
+    return fallback;
+  }
+}
+function robustJsonParse(jsonString, fallback = null) {
+  if (!jsonString) return fallback;
+  if (typeof jsonString === "object") return jsonString;
+  try {
+    return JSON.parse(jsonString);
+  } catch {
+    return fallback;
+  }
+}
+
+// ../../lib/pglite/maintenance.ts
+async function checkpointDatabase() {
+  const db = await getDB();
+  try {
+    await db.exec("CHECKPOINT");
+  } catch (err) {
+    console.warn("[PGLite] CHECKPOINT failed:", err);
+  }
+}
+async function resetDatabase(scope) {
+  const oldDataDir = scope ? getDataDirForScope(scope) : getCurrentDataDir();
+  shutdownPool();
+  await deleteDatabaseByDataDir(oldDataDir);
+  if (scope) {
+    setDbScope(scope);
+  }
+}
+
+// ../../lib/pglite/queries/progress.ts
+async function getUserProgress(userId, quizId) {
+  console.log("PGLITE_DEBUG: getUserProgress called with userId:", userId, "quizId:", quizId);
+  const db = await getDB();
+  if (!userId || !quizId) return null;
+  const result = await db.query(
+    "SELECT * FROM user_progress WHERE user_id = $1 AND quiz_id = $2;",
+    [userId, quizId]
+  );
+  return result.rows[0] || null;
+}
+async function getAllUserProgress(userId) {
+  if (process.env.NEXT_PUBLIC_DEBUG_DB === "true") {
+    console.log("PGLITE_DEBUG: getAllUserProgress called with userId:", userId);
+  }
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    if (!userId) return [];
+    const result = await db.query(
+      "SELECT * FROM user_progress WHERE user_id = $1;",
+      [userId]
+    );
+    return result.rows;
+  }, []);
+}
+async function upsertUserProgress(progress) {
+  const db = await getDB();
+  if (!progress.user_id || !progress.quiz_id) {
+    throw new Error("User ID and Quiz ID are required for upsertUserProgress");
+  }
+  const {
+    user_id,
+    quiz_id,
+    highest_score,
+    completed_at,
+    unlocked_rewards,
+    current_question_index,
+    answers
+  } = progress;
+  const result = await db.query(
+    `INSERT INTO user_progress (user_id, quiz_id, highest_score, completed_at, unlocked_rewards, current_question_index, answers, last_attempted_at)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, CURRENT_TIMESTAMP)
+     ON CONFLICT (user_id, quiz_id) DO UPDATE SET
+       highest_score = GREATEST(EXCLUDED.highest_score, user_progress.highest_score),
+       completed_at = COALESCE(EXCLUDED.completed_at, user_progress.completed_at),
+       unlocked_rewards = COALESCE(EXCLUDED.unlocked_rewards, user_progress.unlocked_rewards),
+       current_question_index = EXCLUDED.current_question_index,
+       answers = EXCLUDED.answers,
+       last_attempted_at = CURRENT_TIMESTAMP
+     RETURNING *;`,
+    [
+      user_id,
+      quiz_id,
+      highest_score,
+      completed_at,
+      JSON.stringify(unlocked_rewards || []),
+      current_question_index,
+      JSON.stringify(answers || {})
+    ]
+  );
+  return result.rows[0];
+}
+
+// ../../lib/pglite/queries/user.ts
+async function getUserProfileByXverseAddress(address) {
+  if (process.env.NEXT_PUBLIC_DEBUG_DB === "true") {
+    console.log("PGLITE_DEBUG: getUserProfileByXverseAddress called with address:", address);
+  }
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    if (!address) return null;
+    const result = await db.query(
+      "SELECT * FROM user_profiles WHERE xverse_ord_address = $1;",
+      [address]
+    );
+    return result.rows[0] || null;
+  }, null);
+}
+async function getUserProfile(userId) {
+  if (process.env.NEXT_PUBLIC_DEBUG_DB === "true") {
+    console.log("PGLITE_DEBUG: getUserProfile called with userId:", userId);
+  }
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    if (!userId) return null;
+    const result = await db.query(
+      "SELECT * FROM user_profiles WHERE user_id = $1;",
+      [userId]
+    );
+    return result.rows[0] || null;
+  }, null);
+}
+async function getEffectiveOrCreateUserProfile(walletAddress, anonymousUserIdProvider) {
+  const db = await getDB();
+  if (walletAddress) {
+    const existingProfile = await getUserProfileByXverseAddress(walletAddress);
+    if (existingProfile && existingProfile.user_id) {
+      console.log(
+        `PGLITE_DEBUG: Found existing profile for wallet ${walletAddress} by address, user_id: ${existingProfile.user_id}`
+      );
+      return existingProfile.user_id;
+    }
+    console.log(
+      `PGLITE_DEBUG: No existing profile found for wallet ${walletAddress}. Attempting to create.`
+    );
+    try {
+      const newUuid = crypto.randomUUID();
+      const createdProfile = await createUserProfile({
+        user_id: newUuid,
+        username: null,
+        avatar_url: null,
+        xverse_ord_address: walletAddress,
+        shape_hash: null,
+        preferences: { unlocked_reward_ids: [] },
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      console.log(
+        `PGLITE_DEBUG: Successfully created profile for wallet ${walletAddress}, user_id: ${createdProfile.user_id}`
+      );
+      return createdProfile.user_id;
+    } catch (error) {
+      let isUniqueViolation = false;
+      const err = error;
+      const errStr = String(err?.message || err?.toString?.() || "").toLowerCase();
+      if (err?.code === "23505") {
+        isUniqueViolation = true;
+      } else if (errStr.includes("unique constraint") || errStr.includes("duplicate key")) {
+        if (errStr.includes("user_profiles_xverse_ord_address_key") || errStr.includes("unique constraint failed")) {
+          isUniqueViolation = true;
+        }
+      }
+      if (isUniqueViolation) {
+        console.warn(
+          `PGLITE_DEBUG: Create failed for wallet ${walletAddress} due to unique constraint (Code: ${err?.code}, Message: ${errStr}). This might happen if a concurrent creation succeeded. Fetching again...`
+        );
+        const profileAfterConcurrentCreate = await getUserProfileByXverseAddress(walletAddress);
+        if (profileAfterConcurrentCreate && profileAfterConcurrentCreate.user_id) {
+          console.log(
+            `PGLITE_DEBUG: Fetched profile for wallet ${walletAddress} after concurrent creation, user_id: ${profileAfterConcurrentCreate.user_id}`
+          );
+          return profileAfterConcurrentCreate.user_id;
+        } else {
+          console.error(
+            `PGLITE_ERROR: Profile creation for ${walletAddress} failed unique constraint, and subsequent fetch also failed. This indicates a deeper issue.`
+          );
+          throw new Error(
+            `Failed to get or create profile for wallet ${walletAddress}: Unique constraint hit, but profile not found subsequently.`
+          );
+        }
+      } else {
+        console.error(
+          `PGLITE_ERROR: Error during profile creation for wallet ${walletAddress} (not a recognized unique violation):`,
+          error
+        );
+        throw error;
+      }
+    }
+  } else {
+    const anonymousUuid = anonymousUserIdProvider();
+    if (!anonymousUuid) {
+      const newAnonUuid = crypto.randomUUID();
+      console.warn(
+        "anonymousUserIdProvider returned null/empty, generated a new UUID:",
+        newAnonUuid
+      );
+      const profile2 = await getUserProfile(newAnonUuid);
+      if (profile2 && profile2.user_id) {
+        return profile2.user_id;
+      }
+      const createdProfile = await createUserProfile({
+        user_id: newAnonUuid,
+        username: "Anonymous",
+        avatar_url: null,
+        xverse_ord_address: null,
+        shape_hash: null,
+        preferences: { unlocked_reward_ids: [] },
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return createdProfile.user_id;
+    }
+    const profile = await getUserProfile(anonymousUuid);
+    if (profile && profile.user_id) {
+      return profile.user_id;
+    } else {
+      console.log(`No profile for anonymous UUID ${anonymousUuid}, creating new profile.`);
+      const createdProfile = await createUserProfile({
+        user_id: anonymousUuid,
+        username: "Anonymous",
+        avatar_url: null,
+        xverse_ord_address: null,
+        shape_hash: null,
+        preferences: { unlocked_reward_ids: [] },
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return createdProfile.user_id;
+    }
+  }
+}
+async function createUserProfile(profileData) {
+  const db = await getDB();
+  const preferences = profileData.preferences || { unlocked_reward_ids: [] };
+  if (!preferences.unlocked_reward_ids) {
+    preferences.unlocked_reward_ids = [];
+  }
+  const result = await db.query(
+    `INSERT INTO user_profiles (user_id, username, avatar_url, xverse_ord_address, shape_hash, api_keys, preferences)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)
+     ON CONFLICT (user_id)
+     DO UPDATE SET
+       username = COALESCE(EXCLUDED.username, user_profiles.username),
+       avatar_url = COALESCE(EXCLUDED.avatar_url, user_profiles.avatar_url),
+       xverse_ord_address = COALESCE(EXCLUDED.xverse_ord_address, user_profiles.xverse_ord_address),
+       shape_hash = COALESCE(EXCLUDED.shape_hash, user_profiles.shape_hash),
+       api_keys = COALESCE(EXCLUDED.api_keys, user_profiles.api_keys),
+       preferences = COALESCE(EXCLUDED.preferences, user_profiles.preferences),
+       updated_at = CURRENT_TIMESTAMP
+     RETURNING *;`,
+    [
+      profileData.user_id,
+      profileData.username,
+      profileData.avatar_url,
+      profileData.xverse_ord_address,
+      profileData.shape_hash,
+      profileData.api_keys ? JSON.stringify(profileData.api_keys) : "{}",
+      JSON.stringify(preferences)
+    ]
+  );
+  if (result.rows.length === 0) {
+    throw new Error("Failed to create user profile.");
+  }
+  return result.rows[0];
+}
+async function updateUserProfile(userId, updates) {
+  const db = await getDB();
+  if (!userId) {
+    console.error("updateUserProfile called with empty userId");
+    return null;
+  }
+  const setClauses = [];
+  const values = [userId];
+  let paramIndex = 2;
+  for (const [key, value] of Object.entries(updates)) {
+    if ((key === "preferences" || key === "api_keys") && typeof value === "object" && value !== null) {
+      setClauses.push(`${key} = $${paramIndex++}`);
+      values.push(JSON.stringify(value));
+    } else if (key !== "preferences" && key !== "api_keys" && key !== "user_id" && value !== void 0) {
+      setClauses.push(`${key} = $${paramIndex++}`);
+      values.push(value);
+    }
+  }
+  if (setClauses.length === 0) {
+    return getUserProfile(userId);
+  }
+  const query = `UPDATE user_profiles SET ${setClauses.join(", ")}, updated_at = CURRENT_TIMESTAMP WHERE user_id = $1 RETURNING *;`;
+  const result = await db.query(query, values);
+  return result.rows[0] || null;
+}
+async function saveUserArtifact(artifact) {
+  const db = await getDB();
+  const result = await db.query(
+    `INSERT INTO user_artifacts (user_id, source_applet, artifact_type, display_type, artifact_name, content, blob_content, metadata)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+     RETURNING *;`,
+    [
+      artifact.user_id,
+      artifact.source_applet,
+      artifact.artifact_type,
+      artifact.display_type || null,
+      artifact.artifact_name,
+      artifact.content || null,
+      artifact.blob_content || null,
+      artifact.metadata ? JSON.stringify(artifact.metadata) : null
+    ]
+  );
+  return result.rows[0];
+}
+async function getUserArtifacts(userId, sourceApplet) {
+  const db = await getDB();
+  if (sourceApplet) {
+    const result2 = await db.query(
+      "SELECT * FROM user_artifacts WHERE user_id = $1 AND source_applet = $2 ORDER BY created_at DESC;",
+      [userId, sourceApplet]
+    );
+    return result2.rows;
+  }
+  const result = await db.query(
+    "SELECT * FROM user_artifacts WHERE user_id = $1 ORDER BY created_at DESC;",
+    [userId]
+  );
+  return result.rows;
+}
+async function getUserArtifactById(artifactId) {
+  const db = await getDB();
+  const result = await db.query("SELECT * FROM user_artifacts WHERE id = $1;", [
+    artifactId
+  ]);
+  return result.rows[0] || null;
+}
+async function deleteUserArtifact(artifactId) {
+  const db = await getDB();
+  const result = await db.query("DELETE FROM user_artifacts WHERE id = $1;", [artifactId]);
+  return result.affectedRows !== void 0 && result.affectedRows > 0;
+}
+
+// ../../lib/pglite/queries/quiz.ts
+async function getAllQuizzes() {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    const result = await db.query("SELECT * FROM quizzes ORDER BY title;");
+    return result.rows;
+  }, []);
+}
+async function getQuizById(id) {
+  const db = await getDB();
+  const result = await db.query("SELECT * FROM quizzes WHERE id = $1;", [id]);
+  return result.rows[0] || null;
+}
+var GET_ALL_QUIZZES_WITH_USER_PROGRESS_SQL = `
+  SELECT
+    q.*,
+    up.highest_score,
+    CASE WHEN up.completed_at IS NOT NULL THEN TRUE ELSE FALSE END as is_completed
+  FROM quizzes q
+  LEFT JOIN user_progress up ON q.id = up.quiz_id AND up.user_id = $1
+  ORDER BY q.title;
+`;
+async function getAllQuizzesWithUserProgress(userId) {
+  console.log("PGLITE_DEBUG: getAllQuizzesWithUserProgress called with userId:", userId);
+  const db = await getDB();
+  const result = await db.query(
+    GET_ALL_QUIZZES_WITH_USER_PROGRESS_SQL,
+    [userId]
+  );
+  return result.rows.map((row) => ({
+    ...row,
+    questions: row.questions ? typeof row.questions === "string" ? JSON.parse(row.questions) : row.questions : []
+  }));
+}
+var SEARCH_QUIZZES_SQL = `
+  SELECT q.*,
+    similarity(q.title, $1) AS title_sim,
+    similarity(COALESCE(q.description, ''), $1) AS desc_sim
+  FROM quizzes q
+  WHERE q.title % $1 OR COALESCE(q.description, '') % $1
+  ORDER BY GREATEST(
+    similarity(q.title, $1),
+    similarity(COALESCE(q.description, ''), $1)
+  ) DESC;
+`;
+async function searchQuizzes(searchText) {
+  const db = await getDB();
+  if (!searchText) {
+    return getAllQuizzes();
+  }
+  await db.exec(`SELECT set_limit(0.1);`);
+  const result = await db.query(SEARCH_QUIZZES_SQL, [searchText]);
+  return result.rows;
+}
+async function checkQuizCompletion(userId, quizId) {
+  const db = await getDB();
+  if (!userId || !quizId) return false;
+  const result = await db.query(
+    "SELECT completed_at FROM user_progress WHERE user_id = $1 AND quiz_id = $2;",
+    [userId, quizId]
+  );
+  const progress = result.rows[0];
+  return !!progress && progress.completed_at !== null;
+}
+async function getAllRewards() {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    const result = await db.query("SELECT * FROM rewards ORDER BY title;");
+    return result.rows;
+  }, []);
+}
+async function getRewardById(id) {
+  const db = await getDB();
+  const result = await db.query("SELECT * FROM rewards WHERE id = $1;", [id]);
+  return result.rows[0] || null;
+}
+async function completeQuizAndProcessRewards(userId, quizId, score) {
+  if (process.env.NEXT_PUBLIC_DEBUG_DB === "true") {
+    console.log(
+      "PGLITE_DEBUG: completeQuizAndProcessRewards called with userId:",
+      userId,
+      "quizId:",
+      quizId
+    );
+  }
+  const db = await getDB();
+  if (!userId || !quizId) {
+    console.error("User ID and Quiz ID are required for completeQuizAndProcessRewards");
+    return [];
+  }
+  const unlockedRewardsForThisQuiz = [];
+  await upsertUserProgress({
+    user_id: userId,
+    quiz_id: quizId,
+    highest_score: score,
+    completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    unlocked_rewards: [],
+    current_question_index: null,
+    answers: null
+  });
+  console.log(`Quiz ${quizId} marked as completed for user ${userId} with score ${score}`);
+  const allUserProgressEntries = await getAllUserProgress(userId);
+  const completedQuizIds = new Set(
+    allUserProgressEntries.filter((p) => p.completed_at).map((p) => p.quiz_id)
+  );
+  const allRewardsList = await getAllRewards();
+  let userProfile = await getUserProfile(userId);
+  if (!userProfile) {
+    if (process.env.NEXT_PUBLIC_DEBUG_DB === "true") {
+      console.error(
+        `Profile not found for UUID ${userId} in completeQuizAndProcessRewards. This might indicate an issue if getEffectiveOrCreateUserProfile was not called prior.`
+      );
+    }
+    userProfile = await createUserProfile({
+      user_id: userId,
+      username: null,
+      avatar_url: null,
+      xverse_ord_address: null,
+      shape_hash: null,
+      preferences: { unlocked_reward_ids: [] },
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  const preferences = userProfile.preferences || { unlocked_reward_ids: [] };
+  if (!preferences.unlocked_reward_ids) {
+    preferences.unlocked_reward_ids = [];
+  }
+  const currentUserUnlockedRewardIds = new Set(preferences.unlocked_reward_ids);
+  for (const reward of allRewardsList) {
+    if (!currentUserUnlockedRewardIds.has(reward.id)) {
+      const requiredQuizzes = reward.quiz_ids_required || [];
+      if (requiredQuizzes.length === 0 || requiredQuizzes.every((reqQuizId) => completedQuizIds.has(reqQuizId))) {
+        currentUserUnlockedRewardIds.add(reward.id);
+        unlockedRewardsForThisQuiz.push(reward.id);
+      }
+    }
+  }
+  if (unlockedRewardsForThisQuiz.length > 0) {
+    const updatedPreferences = {
+      ...preferences,
+      unlocked_reward_ids: Array.from(currentUserUnlockedRewardIds)
+    };
+    await updateUserProfile(userId, { preferences: updatedPreferences });
+    if (process.env.NEXT_PUBLIC_DEBUG_DB === "true") {
+      console.log(`User ${userId} unlocked new rewards: ${unlockedRewardsForThisQuiz.join(", ")}`);
+    }
+  }
+  return unlockedRewardsForThisQuiz;
+}
+async function unlockReward(userId, rewardId) {
+  if (process.env.NEXT_PUBLIC_DEBUG_DB === "true") {
+    console.log("PGLITE_DEBUG: unlockReward called with userId:", userId, "rewardId:", rewardId);
+  }
+  const db = await getDB();
+  if (!userId || !rewardId) {
+    console.error("User ID and Reward ID are required for unlockReward");
+    return false;
+  }
+  try {
+    let userProfile = await getUserProfile(userId);
+    if (!userProfile) {
+      console.error(`Profile not found for UUID ${userId} in unlockReward.`);
+      userProfile = await createUserProfile({
+        user_id: userId,
+        username: null,
+        avatar_url: null,
+        xverse_ord_address: null,
+        shape_hash: null,
+        preferences: { unlocked_reward_ids: [rewardId] },
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (process.env.NEXT_PUBLIC_DEBUG_DB === "true") {
+        console.log(
+          `Reward ${rewardId} unlocked for new user profile (UUID ${userId}) via direct call in unlockReward.`
+        );
+      }
+      return true;
+    }
+    const preferences = userProfile.preferences || { unlocked_reward_ids: [] };
+    if (!preferences.unlocked_reward_ids) {
+      preferences.unlocked_reward_ids = [];
+    }
+    const unlockedRewardIdsSet = new Set(preferences.unlocked_reward_ids);
+    if (unlockedRewardIdsSet.has(rewardId)) {
+      if (process.env.NEXT_PUBLIC_DEBUG_DB === "true") {
+        console.log(`Reward ${rewardId} already unlocked for user ${userId}.`);
+      }
+      return false;
+    }
+    unlockedRewardIdsSet.add(rewardId);
+    const updatedPreferences = {
+      ...preferences,
+      unlocked_reward_ids: Array.from(unlockedRewardIdsSet)
+    };
+    await updateUserProfile(userId, { preferences: updatedPreferences });
+    if (process.env.NEXT_PUBLIC_DEBUG_DB === "true") {
+      console.log(`Reward ${rewardId} unlocked for user ${userId} via direct call.`);
+    }
+    return true;
+  } catch (error) {
+    console.error("PGLiteService: Error unlocking reward:", error);
+    return false;
+  }
+}
+
+// ../../lib/pglite/queries/resources.ts
+async function getAllResourceCategories() {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM resource_categories ORDER BY name;"
+  );
+  return result.rows;
+}
+async function getResourceCategoryById(id) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM resource_categories WHERE id = $1;",
+    [id]
+  );
+  return result.rows[0] || null;
+}
+async function searchResourceCategories(searchText, similarityThreshold = 0.1) {
+  const db = await getDB();
+  if (!searchText) {
+    return getAllResourceCategories();
+  }
+  await db.exec(`SELECT set_limit(${similarityThreshold});`);
+  const query = `
+    SELECT *,
+      similarity(name, $1) AS name_similarity,
+      similarity(description, $1) AS description_similarity
+    FROM resource_categories
+    WHERE (
+      name % $1 OR
+      description % $1
+    )
+    ORDER BY GREATEST(similarity(name, $1), similarity(description, $1)) DESC;
+  `;
+  const result = await db.query(query, [searchText]);
+  return result.rows;
+}
+async function getAllResourceDocuments(categoryId) {
+  const db = await getDB();
+  if (categoryId) {
+    const result2 = await db.query(
+      "SELECT * FROM resource_documents WHERE category_id = $1 ORDER BY title;",
+      [categoryId]
+    );
+    return result2.rows;
+  }
+  const result = await db.query(
+    "SELECT * FROM resource_documents ORDER BY title;"
+  );
+  return result.rows;
+}
+async function getResourceDocumentById(id) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM resource_documents WHERE id = $1;",
+    [id]
+  );
+  return result.rows[0] || null;
+}
+async function searchResourceDocuments(searchText, categoryId, similarityThreshold = 0.1) {
+  const db = await getDB();
+  if (!searchText) {
+    return getAllResourceDocuments(categoryId);
+  }
+  await db.exec(`SELECT set_limit(${similarityThreshold});`);
+  let query = `
+    SELECT *,
+      similarity(title, $1) AS title_similarity,
+      similarity(content, $1) AS content_similarity,
+      similarity(array_to_string(tags, ' '), $1) AS tags_similarity
+    FROM resource_documents
+    WHERE (
+      title % $1 OR
+      content % $1 OR
+      array_to_string(tags, ' ') % $1
+    )
+  `;
+  const params = [searchText];
+  if (categoryId) {
+    query += ` AND category_id = $2`;
+    params.push(categoryId);
+  }
+  query += `
+    ORDER BY GREATEST(
+      similarity(title, $1),
+      similarity(content, $1),
+      similarity(array_to_string(tags, ' '), $1)
+    ) DESC;
+  `;
+  const result = await db.query(query, params);
+  return result.rows;
+}
+async function getAllFriends() {
+  const db = await getDB();
+  const result = await db.query("SELECT * FROM friends ORDER BY name;");
+  return result.rows;
+}
+async function getAllInspirations() {
+  const db = await getDB();
+  const result = await db.query("SELECT * FROM inspirations ORDER BY name;");
+  return result.rows;
+}
+
+// ../../lib/pglite/queries/chat.ts
+var connectionPool = PGLiteConnectionPool.getInstance();
+async function createChatSession(params = {}) {
+  const db = await getDB();
+  const newSessionId = params.sessionId || crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await db.query(
+    "INSERT INTO chat_sessions (id, user_id, session_title, created_at, updated_at, metadata) VALUES ($1, $2, $3, $4, $5, $6) RETURNING *;",
+    [
+      newSessionId,
+      params.userId || null,
+      params.sessionTitle || `Session ${newSessionId.substring(0, 8)}`,
+      now,
+      now,
+      JSON.stringify(params.metadata || {})
+    ]
+  );
+  if (result.rows.length === 0) {
+    throw new Error("Failed to create chat session.");
+  }
+  return result.rows[0];
+}
+async function getAllChatSessions(userId) {
+  if (!connectionPool.getStats().isInitialized) {
+    console.warn("PGLite connection pool not ready, returning empty chat sessions array");
+    return [];
+  }
+  try {
+    const db = await getDB();
+    if (userId) {
+      const result = await db.query(
+        "SELECT * FROM chat_sessions WHERE user_id = $1 ORDER BY updated_at DESC;",
+        [userId]
+      );
+      return result.rows;
+    } else {
+      const result = await db.query(
+        "SELECT * FROM chat_sessions ORDER BY updated_at DESC;"
+      );
+      return result.rows;
+    }
+  } catch (error) {
+    console.error("Error in getAllChatSessions:", error);
+    return [];
+  }
+}
+async function getChatSession(sessionId, userId) {
+  const db = await getDB();
+  if (!sessionId) return null;
+  let query = "SELECT * FROM chat_sessions WHERE id = $1";
+  const queryParams = [sessionId];
+  if (userId) {
+    query += " AND user_id = $2";
+    queryParams.push(userId);
+  }
+  const result = await db.query(query, queryParams);
+  return result.rows[0] || null;
+}
+async function updateChatSessionTitle(sessionId, newTitle, userId) {
+  const db = await getDB();
+  if (!sessionId) return;
+  let query = "UPDATE chat_sessions SET session_title = $1, updated_at = CURRENT_TIMESTAMP WHERE id = $2";
+  const queryParams = [newTitle, sessionId];
+  if (userId) {
+    query += " AND user_id = $3";
+    queryParams.push(userId);
+  }
+  await db.query(query, queryParams);
+}
+async function deleteChatSession(sessionId, userId) {
+  if (!userId) {
+    throw new Error("deleteChatSession requires a valid userId to prevent cross-user data access.");
+  }
+  const db = await getDB();
+  if (!sessionId) return;
+  const query = "DELETE FROM chat_sessions WHERE id = $1 AND user_id = $2";
+  await db.query(query, [sessionId, userId]);
+}
+async function clearChatMessages(sessionId, userId) {
+  if (!userId) {
+    throw new Error("clearChatMessages requires a valid userId to prevent cross-user data access.");
+  }
+  const db = await getDB();
+  if (!sessionId) return;
+  const checkOwner = await db.query("SELECT 1 FROM chat_sessions WHERE id = $1 AND user_id = $2", [
+    sessionId,
+    userId
+  ]);
+  if (checkOwner.rows.length === 0) {
+    throw new Error("Unauthorized: session does not belong to requesting user.");
+  }
+  await db.query("DELETE FROM chat_messages WHERE session_id = $1;", [sessionId]);
+}
+async function addChatMessage(params) {
+  const db = await getDB();
+  const { sessionId, role, content, userId, messageId, toolCallId, toolCalls, name, metadata } = params;
+  const newChatMessageId = messageId || crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await db.query(
+    "INSERT INTO chat_messages (id, session_id, user_id, role, content, tool_call_id, tool_calls, name, timestamp, metadata) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING *;",
+    [
+      newChatMessageId,
+      sessionId,
+      userId || null,
+      role,
+      content,
+      toolCallId || null,
+      toolCalls ? JSON.stringify(toolCalls) : null,
+      name || null,
+      now,
+      JSON.stringify(metadata || {})
+    ]
+  );
+  if (result.rows.length === 0) {
+    throw new Error("Failed to add chat message.");
+  }
+  return result.rows[0];
+}
+async function getChatMessages(sessionId, limit = 100, offset = 0) {
+  const db = await getDB();
+  try {
+    const result = await db.query(
+      `
+      SELECT id, session_id, role, content, user_id, tool_call_id, tool_calls, name,
+             to_char(timestamp, 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"') as timestamp, metadata
+      FROM chat_messages
+      WHERE session_id = $1
+      ORDER BY timestamp ASC
+      LIMIT $2 OFFSET $3;
+    `,
+      [sessionId, limit, offset]
+    );
+    return result.rows.map((row) => ({
+      ...row,
+      tool_calls: robustJsonParse(row.tool_calls, null),
+      metadata: robustJsonParse(row.metadata, null)
+    }));
+  } catch (error) {
+    console.error("PGLiteService: Error getting chat messages:", error);
+    throw error;
+  }
+}
+async function getChatMessageCount(sessionId) {
+  const db = await getDB();
+  if (!sessionId) return 0;
+  try {
+    const result = await db.query(
+      `
+      SELECT COUNT(*) FROM chat_messages WHERE session_id = $1;
+    `,
+      [sessionId]
+    );
+    return result.rows[0]?.count || 0;
+  } catch (error) {
+    console.error("PGLiteService: Error getting chat message count:", error);
+    return 0;
+  }
+}
+
+// ../../lib/pglite/queries/deploy.ts
+async function createDeployment(params) {
+  const db = await getDB();
+  const id = params.id || crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await db.query(
+    `INSERT INTO deployments (id, user_id, stack_id, provider, status, deploy_url, preview_url, inspector_url, error, config, created_at, updated_at)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+     RETURNING *;`,
+    [
+      id,
+      params.user_id ?? null,
+      params.stack_id ?? null,
+      params.provider,
+      params.status ?? "idle",
+      params.deploy_url ?? null,
+      params.preview_url ?? null,
+      params.inspector_url ?? null,
+      params.error ?? null,
+      params.config ? JSON.stringify(params.config) : null,
+      now,
+      now
+    ]
+  );
+  if (result.rows.length === 0) {
+    throw new Error("Failed to create deployment.");
+  }
+  return result.rows[0];
+}
+async function getDeployment(id) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM deployments WHERE id = $1;",
+    [id]
+  );
+  return result.rows[0] || null;
+}
+async function getDeploymentsByStack(stackId, limit = 50) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM deployments WHERE stack_id = $1 ORDER BY created_at DESC LIMIT $2;",
+    [stackId, limit]
+  );
+  return result.rows;
+}
+async function getDeploymentsByUser(userId, limit = 50) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM deployments WHERE user_id = $1 ORDER BY created_at DESC LIMIT $2;",
+    [userId, limit]
+  );
+  return result.rows;
+}
+async function updateDeploymentStatus(id, status, fields) {
+  const db = await getDB();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const setClauses = ["status = $2", "updated_at = $3"];
+  const queryParams = [id, status, now];
+  let paramIdx = 4;
+  if (fields?.deploy_url !== void 0) {
+    setClauses.push(`deploy_url = $${paramIdx}`);
+    queryParams.push(fields.deploy_url);
+    paramIdx++;
+  }
+  if (fields?.preview_url !== void 0) {
+    setClauses.push(`preview_url = $${paramIdx}`);
+    queryParams.push(fields.preview_url);
+    paramIdx++;
+  }
+  if (fields?.inspector_url !== void 0) {
+    setClauses.push(`inspector_url = $${paramIdx}`);
+    queryParams.push(fields.inspector_url);
+    paramIdx++;
+  }
+  if (fields?.error !== void 0) {
+    setClauses.push(`error = $${paramIdx}`);
+    queryParams.push(fields.error);
+    paramIdx++;
+  }
+  const result = await db.query(
+    `UPDATE deployments SET ${setClauses.join(", ")} WHERE id = $1 RETURNING *;`,
+    queryParams
+  );
+  return result.rows[0] || null;
+}
+async function deleteDeployment(id) {
+  const db = await getDB();
+  const result = await db.query("DELETE FROM deployments WHERE id = $1;", [id]);
+  return (result.affectedRows ?? 0) > 0;
+}
+
+// ../../lib/pglite/queries/workspace.ts
+function parseWorkspaceRow(row) {
+  return {
+    id: row.id,
+    user_id: row.user_id,
+    stack_id: row.stack_id || null,
+    open_files: robustJsonParse(row.open_files, []) ?? [],
+    active_file: row.active_file || null,
+    cursor_positions: robustJsonParse(
+      row.cursor_positions,
+      {}
+    ) ?? {},
+    scroll_positions: robustJsonParse(row.scroll_positions, {}) ?? {},
+    pane_layout: robustJsonParse(row.pane_layout, null),
+    editor_settings: robustJsonParse(row.editor_settings, null),
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+async function getWorkspaceState(userId, stackId) {
+  const db = await getDB();
+  let query;
+  let params;
+  if (stackId) {
+    query = "SELECT * FROM workspace_state WHERE user_id = $1 AND stack_id = $2;";
+    params = [userId, stackId];
+  } else {
+    query = "SELECT * FROM workspace_state WHERE user_id = $1 AND stack_id IS NULL;";
+    params = [userId];
+  }
+  const result = await db.query(query, params);
+  if (result.rows.length === 0) return null;
+  return parseWorkspaceRow(result.rows[0]);
+}
+async function saveWorkspaceState(state) {
+  const db = await getDB();
+  const id = state.id || crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await db.query(
+    `INSERT INTO workspace_state (id, user_id, stack_id, open_files, active_file, cursor_positions, scroll_positions, pane_layout, editor_settings, created_at, updated_at)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+     ON CONFLICT (id) DO UPDATE SET
+       open_files = EXCLUDED.open_files,
+       active_file = EXCLUDED.active_file,
+       cursor_positions = EXCLUDED.cursor_positions,
+       scroll_positions = EXCLUDED.scroll_positions,
+       pane_layout = EXCLUDED.pane_layout,
+       editor_settings = EXCLUDED.editor_settings,
+       updated_at = EXCLUDED.updated_at
+     RETURNING *;`,
+    [
+      id,
+      state.user_id,
+      state.stack_id ?? null,
+      JSON.stringify(state.open_files),
+      state.active_file ?? null,
+      JSON.stringify(state.cursor_positions),
+      JSON.stringify(state.scroll_positions),
+      state.pane_layout ? JSON.stringify(state.pane_layout) : null,
+      state.editor_settings ? JSON.stringify(state.editor_settings) : null,
+      now,
+      now
+    ]
+  );
+  if (result.rows.length === 0) {
+    throw new Error("Failed to save workspace state.");
+  }
+  return parseWorkspaceRow(result.rows[0]);
+}
+async function deleteWorkspaceState(id) {
+  const db = await getDB();
+  const result = await db.query("DELETE FROM workspace_state WHERE id = $1;", [id]);
+  return (result.affectedRows ?? 0) > 0;
+}
+async function getAllWorkspaceStates(userId) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM workspace_state WHERE user_id = $1 ORDER BY updated_at DESC;",
+    [userId]
+  );
+  return result.rows.map(parseWorkspaceRow);
+}
+
+// ../../lib/pglite/queries/skill-runs.ts
+async function createSkillRun(params) {
+  const db = await getDB();
+  const id = params.id || crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await db.query(
+    `INSERT INTO skill_runs (id, user_id, skill_slug, status, input, created_at, updated_at)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)
+     RETURNING *;`,
+    [
+      id,
+      params.user_id ?? null,
+      params.skill_slug,
+      params.status ?? "pending",
+      params.input ? JSON.stringify(params.input) : null,
+      now,
+      now
+    ]
+  );
+  if (result.rows.length === 0) {
+    throw new Error("Failed to create skill run.");
+  }
+  return result.rows[0];
+}
+async function getSkillRun(id) {
+  const db = await getDB();
+  const result = await db.query("SELECT * FROM skill_runs WHERE id = $1;", [id]);
+  return result.rows[0] || null;
+}
+async function getSkillRunsBySlug(skillSlug, limit = 50) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM skill_runs WHERE skill_slug = $1 ORDER BY created_at DESC LIMIT $2;",
+    [skillSlug, limit]
+  );
+  return result.rows;
+}
+async function getSkillRunsByUser(userId, limit = 50) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM skill_runs WHERE user_id = $1 ORDER BY created_at DESC LIMIT $2;",
+    [userId, limit]
+  );
+  return result.rows;
+}
+var IMMUTABLE_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+async function updateSkillRunStatus(id, status, fields) {
+  const db = await getDB();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const setClauses = ["status = $2", "updated_at = $3"];
+  const queryParams = [id, status, now];
+  let paramIdx = 4;
+  if (fields?.artifacts !== void 0) {
+    setClauses.push(`artifacts = $${paramIdx}`);
+    queryParams.push(JSON.stringify(fields.artifacts));
+    paramIdx++;
+  }
+  if (fields?.agent_log !== void 0) {
+    setClauses.push(`agent_log = $${paramIdx}`);
+    queryParams.push(JSON.stringify(fields.agent_log));
+    paramIdx++;
+  }
+  if (fields?.error !== void 0) {
+    setClauses.push(`error = $${paramIdx}`);
+    queryParams.push(fields.error);
+    paramIdx++;
+  }
+  if (fields?.started_at !== void 0) {
+    setClauses.push(`started_at = $${paramIdx}`);
+    queryParams.push(fields.started_at);
+    paramIdx++;
+  }
+  if (fields?.completed_at !== void 0) {
+    setClauses.push(`completed_at = $${paramIdx}`);
+    queryParams.push(fields.completed_at);
+    paramIdx++;
+  }
+  const result = await db.query(
+    `UPDATE skill_runs SET ${setClauses.join(", ")}
+     WHERE id = $1 AND status NOT IN ('completed', 'failed', 'cancelled')
+     RETURNING *;`,
+    queryParams
+  );
+  if (result.rows.length === 0) {
+    const existing = await db.query(
+      "SELECT status FROM skill_runs WHERE id = $1;",
+      [id]
+    );
+    if (existing.rows.length > 0 && IMMUTABLE_STATUSES.has(existing.rows[0].status)) {
+      console.warn(
+        `[SkillRuns] Rejected status update for ${id}: run is already "${existing.rows[0].status}" (immutable)`
+      );
+    }
+    return null;
+  }
+  return result.rows[0];
+}
+async function cleanupOrphanedRuns() {
+  if (!PGLiteConnectionPool.getInstance().getStats().isInitialized) return 0;
+  const db = await getDB();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await db.query(
+    `UPDATE skill_runs SET status = 'failed', error = 'Orphaned: browser closed during execution', updated_at = $1
+     WHERE status = 'running';`,
+    [now]
+  );
+  return result.affectedRows ?? 0;
+}
+async function deleteSkillRun(id) {
+  const db = await getDB();
+  const result = await db.query("DELETE FROM skill_runs WHERE id = $1;", [id]);
+  return (result.affectedRows ?? 0) > 0;
+}
+
+// ../../lib/pglite/queries/forge.ts
+function parseJsonb(val) {
+  return typeof val === "string" ? JSON.parse(val) : val;
+}
+async function saveForgeScene(params) {
+  const db = await getDB();
+  const id = params.id || crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await db.query(
+    `INSERT INTO forge_scenes (id, user_id, name, scene_data, created_at, updated_at)
+     VALUES ($1, $2, $3, $4, $5, $6)
+     ON CONFLICT (id) DO UPDATE SET
+       name = EXCLUDED.name,
+       scene_data = EXCLUDED.scene_data,
+       updated_at = EXCLUDED.updated_at
+     RETURNING *;`,
+    [id, params.user_id ?? null, params.name, JSON.stringify(params.scene_data), now, now]
+  );
+  const row = result.rows[0];
+  return { ...row, scene_data: parseJsonb(row.scene_data) };
+}
+async function getForgeScene(id) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM forge_scenes WHERE id = $1;",
+    [id]
+  );
+  const row = result.rows[0] || null;
+  return row ? { ...row, scene_data: parseJsonb(row.scene_data) } : null;
+}
+async function getForgeScenesByUser(userId, limit = 50) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM forge_scenes WHERE user_id = $1 ORDER BY updated_at DESC LIMIT $2;",
+    [userId, limit]
+  );
+  return result.rows.map((r) => ({ ...r, scene_data: parseJsonb(r.scene_data) }));
+}
+async function deleteForgeScene(id) {
+  const db = await getDB();
+  const result = await db.query("DELETE FROM forge_scenes WHERE id = $1;", [id]);
+  return (result.affectedRows ?? 0) > 0;
+}
+async function saveForgeIteration(params) {
+  const db = await getDB();
+  const id = params.id || crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await db.query(
+    `INSERT INTO forge_iterations (id, scene_id, user_id, tau, sync_order, coherence, parameter_snapshot, created_at)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+     RETURNING *;`,
+    [
+      id,
+      params.scene_id,
+      params.user_id ?? null,
+      params.tau,
+      params.sync_order ?? null,
+      params.coherence ? JSON.stringify(params.coherence) : null,
+      params.parameter_snapshot ? JSON.stringify(params.parameter_snapshot) : null,
+      now
+    ]
+  );
+  const row = result.rows[0];
+  return {
+    ...row,
+    coherence: row.coherence ? parseJsonb(row.coherence) : null,
+    parameter_snapshot: row.parameter_snapshot ? parseJsonb(row.parameter_snapshot) : null
+  };
+}
+async function getForgeIterationsByScene(sceneId, limit = 100) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM forge_iterations WHERE scene_id = $1 ORDER BY created_at DESC LIMIT $2;",
+    [sceneId, limit]
+  );
+  return result.rows.map((r) => ({
+    ...r,
+    coherence: r.coherence ? parseJsonb(r.coherence) : null,
+    parameter_snapshot: r.parameter_snapshot ? parseJsonb(r.parameter_snapshot) : null
+  }));
+}
+async function saveForgeMaterialProfile(params) {
+  const db = await getDB();
+  const id = params.id || crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = await db.query(
+    `INSERT INTO forge_material_profiles (id, user_id, name, properties, acoustic_signature, neural_baseline, crystallization, created_at, updated_at)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+     ON CONFLICT (id) DO UPDATE SET
+       name = EXCLUDED.name,
+       properties = EXCLUDED.properties,
+       acoustic_signature = EXCLUDED.acoustic_signature,
+       neural_baseline = EXCLUDED.neural_baseline,
+       crystallization = EXCLUDED.crystallization,
+       updated_at = EXCLUDED.updated_at
+     RETURNING *;`,
+    [
+      id,
+      params.user_id ?? null,
+      params.name,
+      JSON.stringify(params.properties),
+      params.acoustic_signature ? JSON.stringify(params.acoustic_signature) : null,
+      params.neural_baseline ? JSON.stringify(params.neural_baseline) : null,
+      params.crystallization ?? 0,
+      now,
+      now
+    ]
+  );
+  const row = result.rows[0];
+  return {
+    ...row,
+    properties: parseJsonb(row.properties),
+    acoustic_signature: row.acoustic_signature ? parseJsonb(row.acoustic_signature) : null,
+    neural_baseline: row.neural_baseline ? parseJsonb(row.neural_baseline) : null
+  };
+}
+async function getForgeMaterialProfiles(userId, limit = 50) {
+  const db = await getDB();
+  const result = await db.query(
+    "SELECT * FROM forge_material_profiles WHERE user_id = $1 ORDER BY updated_at DESC LIMIT $2;",
+    [userId, limit]
+  );
+  return result.rows.map((r) => ({
+    ...r,
+    properties: parseJsonb(r.properties),
+    acoustic_signature: r.acoustic_signature ? parseJsonb(r.acoustic_signature) : null,
+    neural_baseline: r.neural_baseline ? parseJsonb(r.neural_baseline) : null
+  }));
+}
+async function deleteForgeMaterialProfile(id) {
+  const db = await getDB();
+  const result = await db.query("DELETE FROM forge_material_profiles WHERE id = $1;", [id]);
+  return (result.affectedRows ?? 0) > 0;
+}
+
+// ../../lib/pglite/queries/biosignal-bridges.ts
+function coerceBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "true" || normalized === "t" || normalized === "1";
+  }
+  return false;
+}
+function normalizeBridgeRow(row) {
+  if (typeof row.id !== "string" || !isBiosignalBridgeId(row.id)) {
+    return null;
+  }
+  const domains = robustJsonParse(row.domains, []);
+  const signalFamilies = robustJsonParse(row.signal_families, []);
+  const config = robustJsonParse(row.config, {}) ?? {};
+  return {
+    id: row.id,
+    label: typeof row.label === "string" ? row.label : row.id,
+    transport: typeof row.transport === "string" ? row.transport : "process",
+    domains: Array.isArray(domains) ? domains : [],
+    signal_families: Array.isArray(signalFamilies) ? signalFamilies : [],
+    status: typeof row.status === "string" ? row.status : "dormant",
+    enabled: coerceBoolean(row.enabled),
+    config,
+    created_at: typeof row.created_at === "string" ? row.created_at : "",
+    updated_at: typeof row.updated_at === "string" ? row.updated_at : ""
+  };
+}
+async function listBiosignalBridgeConfigs() {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    const result = await db.query(
+      `SELECT id, label, transport, domains, signal_families, status, enabled, config, created_at, updated_at
+       FROM biosignal_bridge_config
+       ORDER BY id ASC`
+    );
+    return result.rows.map((row) => normalizeBridgeRow(row)).filter((row) => row !== null);
+  }, []);
+}
+async function getBiosignalBridgeConfig(id) {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    const result = await db.query(
+      `SELECT id, label, transport, domains, signal_families, status, enabled, config, created_at, updated_at
+       FROM biosignal_bridge_config
+       WHERE id = $1
+       LIMIT 1`,
+      [id]
+    );
+    return normalizeBridgeRow(result.rows[0] ?? {});
+  }, null);
+}
+async function listEnabledBiosignalBridges() {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    const result = await db.query(
+      `SELECT id, label, transport, domains, signal_families, status, enabled, config, created_at, updated_at
+       FROM biosignal_bridge_config
+       WHERE enabled = TRUE
+       ORDER BY id ASC`
+    );
+    return result.rows.map((row) => normalizeBridgeRow(row)).filter((row) => row !== null);
+  }, []);
+}
+async function setBiosignalBridgeEnabled(id, enabled) {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    const result = await db.query(
+      `UPDATE biosignal_bridge_config
+       SET enabled = $2,
+           updated_at = CURRENT_TIMESTAMP
+       WHERE id = $1`,
+      [id, enabled]
+    );
+    return (result.affectedRows ?? 0) > 0;
+  }, false);
+}
+async function reseedDormantBiosignalBridges() {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    for (const bridge of DORMANT_BIOSIGNAL_BRIDGES) {
+      await db.query(
+        `INSERT INTO biosignal_bridge_config
+          (id, label, transport, domains, signal_families, status, enabled, config)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+         ON CONFLICT (id) DO NOTHING`,
+        [
+          bridge.id,
+          bridge.label,
+          bridge.transport,
+          JSON.stringify(bridge.domains),
+          JSON.stringify(bridge.signalFamilies),
+          bridge.status,
+          bridge.enabled,
+          JSON.stringify(bridge.config)
+        ]
+      );
+    }
+    return true;
+  }, false);
+}
+
+// ../../lib/pglite/queries/biosignal-providers.ts
+function coerceBoolean2(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "true" || normalized === "t" || normalized === "1";
+  }
+  return false;
+}
+function normalizeProviderRow(row) {
+  if (typeof row.id !== "string" || !isBiosignalProviderId(row.id)) {
+    return null;
+  }
+  const domains = robustJsonParse(row.domains, []);
+  const signalFamilies = robustJsonParse(row.signal_families, []);
+  const metrics = robustJsonParse(row.metrics, []);
+  return {
+    id: row.id,
+    label: typeof row.label === "string" ? row.label : row.id,
+    provider_type: typeof row.provider_type === "string" ? row.provider_type : "gateway",
+    acquisition_mode: typeof row.acquisition_mode === "string" ? row.acquisition_mode : "local",
+    domains: Array.isArray(domains) ? domains : [],
+    signal_families: Array.isArray(signalFamilies) ? signalFamilies : [],
+    metrics: Array.isArray(metrics) ? metrics : [],
+    status: typeof row.status === "string" ? row.status : "dormant",
+    enabled: coerceBoolean2(row.enabled),
+    notes: typeof row.notes === "string" ? row.notes : "",
+    created_at: typeof row.created_at === "string" ? row.created_at : "",
+    updated_at: typeof row.updated_at === "string" ? row.updated_at : ""
+  };
+}
+async function listBiosignalProviderConfigs() {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    const result = await db.query(
+      `SELECT id, label, provider_type, acquisition_mode, domains, signal_families, metrics,
+              status, enabled, notes, created_at, updated_at
+       FROM biosignal_provider_config
+       ORDER BY id ASC`
+    );
+    return result.rows.map((row) => normalizeProviderRow(row)).filter((row) => row !== null);
+  }, []);
+}
+async function getBiosignalProviderConfig(id) {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    const result = await db.query(
+      `SELECT id, label, provider_type, acquisition_mode, domains, signal_families, metrics,
+              status, enabled, notes, created_at, updated_at
+       FROM biosignal_provider_config
+       WHERE id = $1
+       LIMIT 1`,
+      [id]
+    );
+    return normalizeProviderRow(result.rows[0] ?? {});
+  }, null);
+}
+async function listEnabledBiosignalProviders() {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    const result = await db.query(
+      `SELECT id, label, provider_type, acquisition_mode, domains, signal_families, metrics,
+              status, enabled, notes, created_at, updated_at
+       FROM biosignal_provider_config
+       WHERE enabled = TRUE
+       ORDER BY id ASC`
+    );
+    return result.rows.map((row) => normalizeProviderRow(row)).filter((row) => row !== null);
+  }, []);
+}
+async function setBiosignalProviderEnabled(id, enabled) {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    const result = await db.query(
+      `UPDATE biosignal_provider_config
+       SET enabled = $2,
+           updated_at = CURRENT_TIMESTAMP
+       WHERE id = $1`,
+      [id, enabled]
+    );
+    return (result.affectedRows ?? 0) > 0;
+  }, false);
+}
+async function reseedDormantBiosignalProviders() {
+  return safeDbOperation(async () => {
+    const db = await getDB();
+    for (const provider of DORMANT_BIOSIGNAL_PROVIDERS) {
+      await db.query(
+        `INSERT INTO biosignal_provider_config
+          (id, label, provider_type, acquisition_mode, domains, signal_families, metrics, status, enabled, notes)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+         ON CONFLICT (id) DO NOTHING`,
+        [
+          provider.id,
+          provider.label,
+          provider.providerType,
+          provider.acquisitionMode,
+          JSON.stringify(provider.domains),
+          JSON.stringify(provider.signalFamilies),
+          JSON.stringify(provider.metrics),
+          provider.status,
+          provider.enabled,
+          provider.notes
+        ]
+      );
+    }
+    return true;
+  }, false);
+}
+
+// ../../lib/pgliteService.ts
+async function initializeVectorSearch() {
+  const db = await getDB();
+  try {
+    await db.exec(`CREATE EXTENSION IF NOT EXISTS vector;`);
+    const indexExists = await db.query(
+      `SELECT 1 FROM pg_indexes WHERE indexname = 'idx_resource_documents_embedding';`
+    );
+    if (indexExists.rows.length === 0) {
+      await db.exec(
+        `CREATE INDEX idx_resource_documents_embedding ON resource_documents USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);`
+      );
+    }
+  } catch (error) {
+    console.error("Failed to initialize vector search:", error);
+  }
+}
+async function storeDocumentEmbedding(documentId, embedding) {
+  const db = await getDB();
+  await db.query(`UPDATE resource_documents SET embedding = $1 WHERE id = $2;`, [
+    `[${embedding.join(",")}]`,
+    documentId
+  ]);
+}
+async function batchStoreEmbeddings(embeddings) {
+  const db = await getDB();
+  for (const { id, embedding } of embeddings) {
+    await storeDocumentEmbedding(id, embedding);
+  }
+}
+async function searchDocumentsByVector(queryEmbedding, limit = 10) {
+  const db = await getDB();
+  const result = await db.query(
+    `SELECT resource_documents.*, embedding <=> $1 AS similarity_score
+     FROM resource_documents
+     WHERE embedding IS NOT NULL
+     ORDER BY similarity_score
+     LIMIT $2;`,
+    [`[${queryEmbedding.join(",")}]`, limit]
+  );
+  return result.rows.map((row) => ({
+    ...row,
+    similarity_score: Number(row.similarity_score ?? 0),
+    search_type: "semantic"
+  }));
+}
+function escapeLike(input) {
+  return input.replace(/[\\%_]/g, "\\$&");
+}
+async function searchDocumentsByText(query, limit) {
+  const db = await getDB();
+  const trimmed = query.trim();
+  const likeQuery = escapeLike(trimmed);
+  const result = await db.query(
+    `SELECT *, similarity(title, $1) AS similarity_score
+     FROM resource_documents
+     WHERE similarity(title, $1) > 0.1
+        OR title ILIKE '%' || $2 || '%' ESCAPE '\\'
+        OR content ILIKE '%' || $2 || '%' ESCAPE '\\'
+     ORDER BY similarity(title, $1) DESC
+     LIMIT $3;`,
+    [trimmed, likeQuery, limit]
+  );
+  return result.rows.map((row) => ({
+    ...row,
+    similarity_score: Number(row.similarity_score ?? 0),
+    search_type: "text"
+  }));
+}
+async function hybridSearchDocuments(options) {
+  const limit = options.limit ?? 10;
+  const hasVector = options.embedding && options.embedding.length > 0;
+  const hasText = options.query && options.query.trim().length > 0;
+  if (!hasVector && !hasText) return [];
+  if (hasVector && !hasText) {
+    const results = await searchDocumentsByVector(options.embedding, limit);
+    return results.map((row) => ({ ...row, search_type: "semantic" }));
+  }
+  if (hasText && !hasVector) {
+    return searchDocumentsByText(options.query, limit);
+  }
+  const [vectorResults, textResults] = await Promise.all([
+    searchDocumentsByVector(options.embedding, limit * 2),
+    searchDocumentsByText(options.query, limit * 2)
+  ]);
+  const k = 60;
+  const scores = /* @__PURE__ */ new Map();
+  vectorResults.forEach((row, i) => {
+    const rrf = 1 / (k + i + 1);
+    const existing = scores.get(row.id);
+    scores.set(row.id, {
+      score: (existing?.score ?? 0) + rrf,
+      row: existing?.row ?? row
+    });
+  });
+  textResults.forEach((row, i) => {
+    const rrf = 1 / (k + i + 1);
+    const existing = scores.get(row.id);
+    scores.set(row.id, {
+      score: (existing?.score ?? 0) + rrf,
+      row: existing?.row ?? row
+    });
+  });
+  return Array.from(scores.values()).sort((a, b) => b.score - a.score).slice(0, limit).map(({ score, row }) => ({
+    ...row,
+    similarity_score: score,
+    search_type: "hybrid"
+  }));
+}
+async function findSimilarDocuments(documentId, limit = 5) {
+  const db = await getDB();
+  const doc = await db.query(`SELECT embedding FROM resource_documents WHERE id = $1;`, [
+    documentId
+  ]);
+  const row = doc.rows[0];
+  if (!row?.embedding) return [];
+  return searchDocumentsByVector(row.embedding, limit);
+}
+async function getDocumentsWithoutEmbeddings(limit = 100) {
+  const db = await getDB();
+  const result = await db.query(
+    `SELECT id, title, content FROM resource_documents WHERE embedding IS NULL LIMIT $1;`,
+    [limit]
+  );
+  return result.rows;
+}
+async function getVectorSearchMetrics() {
+  const db = await getDB();
+  const total = await db.query(`SELECT COUNT(*) as count FROM resource_documents;`);
+  const withEmbeddings = await db.query(
+    `SELECT COUNT(*) as count FROM resource_documents WHERE embedding IS NOT NULL;`
+  );
+  const totalRow = total.rows[0];
+  const withEmbRow = withEmbeddings.rows[0];
+  const totalCount = parseInt(totalRow?.count || "0", 10);
+  const withEmbCount = parseInt(withEmbRow?.count || "0", 10);
+  return {
+    totalDocuments: totalCount,
+    documentsWithEmbeddings: withEmbCount,
+    documentsWithoutEmbeddings: totalCount - withEmbCount
+  };
+}
+async function upsertConversationEmbedding(params) {
+  const db = await getDB();
+  await db.query(
+    `INSERT INTO conversation_embeddings (session_id, message_id, role, content_snippet, embedding)
+     VALUES ($1, $2, $3, $4, $5)
+     ON CONFLICT (session_id, message_id)
+     DO UPDATE SET embedding = EXCLUDED.embedding;`,
+    [
+      params.sessionId,
+      params.messageId,
+      params.role,
+      params.contentSnippet,
+      `[${params.embedding.join(",")}]`
+    ]
+  );
+}
+async function retrieveTopKForSession(sessionId, queryEmbedding, k = 5) {
+  const db = await getDB();
+  const result = await db.query(
+    `SELECT message_id, role, content_snippet, embedding <=> $1 AS distance
+     FROM conversation_embeddings
+     WHERE session_id = $2
+     ORDER BY distance
+     LIMIT $3;`,
+    [`[${queryEmbedding.join(",")}]`, sessionId, k]
+  );
+  return result.rows;
+}
+async function createSavepoint(name) {
+  const db = await getDB();
+  await db.exec(`SAVEPOINT ${name};`);
+}
+async function rollbackToSavepoint(name) {
+  const db = await getDB();
+  await db.exec(`ROLLBACK TO SAVEPOINT ${name};`);
+}
+async function releaseSavepoint(name) {
+  const db = await getDB();
+  await db.exec(`RELEASE SAVEPOINT ${name};`);
+}
+async function withSavepoint(name, operation) {
+  await createSavepoint(name);
+  try {
+    const result = await operation();
+    await releaseSavepoint(name);
+    return result;
+  } catch (error) {
+    await rollbackToSavepoint(name);
+    throw error;
+  }
+}
+async function saveGenericState(key, value) {
+  const db = await getDB();
+  await db.query(
+    `INSERT INTO key_value_store (key, value) VALUES ($1, $2)
+     ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value;`,
+    [key, JSON.stringify(value)]
+  );
+}
+async function getPgStatIoStats() {
+  const db = await getDB();
+  try {
+    const result = await db.query(`SELECT * FROM pg_stat_io;`);
+    return result.rows;
+  } catch {
+    return [];
+  }
+}
+async function getPGLiteIndexedDbSize() {
+  if (typeof indexedDB === "undefined") return 0;
+  try {
+    const estimate = await navigator.storage?.estimate();
+    return estimate?.usage || 0;
+  } catch {
+    return 0;
+  }
+}
+async function hybridSearch(options) {
+  return hybridSearchDocuments(options);
+}
+async function getKBStats() {
+  const db = await getDB();
+  const docs = await db.query(`SELECT COUNT(*) as count FROM resource_documents;`);
+  const cats = await db.query(`SELECT COUNT(*) as count FROM resource_categories;`);
+  const withEmb = await db.query(
+    `SELECT COUNT(*) as count FROM resource_documents WHERE embedding IS NOT NULL;`
+  );
+  const docsRow = docs.rows[0];
+  const catsRow = cats.rows[0];
+  const withEmbRow = withEmb.rows[0];
+  return {
+    totalDocuments: parseInt(docsRow?.count || "0", 10),
+    totalCategories: parseInt(catsRow?.count || "0", 10),
+    documentsWithEmbeddings: parseInt(withEmbRow?.count || "0", 10)
+  };
+}
+if (typeof window !== "undefined" && process.env.NEXT_PUBLIC_DEBUG_DB === "true")
+  console.log("PGLite service module loaded (backward compatibility layer).");
+
+export {
+  safeDbOperation,
+  robustJsonParse,
+  checkpointDatabase,
+  resetDatabase,
+  getUserProgress,
+  getAllUserProgress,
+  upsertUserProgress,
+  getUserProfileByXverseAddress,
+  getUserProfile,
+  getEffectiveOrCreateUserProfile,
+  createUserProfile,
+  updateUserProfile,
+  saveUserArtifact,
+  getUserArtifacts,
+  getUserArtifactById,
+  deleteUserArtifact,
+  getAllQuizzes,
+  getQuizById,
+  GET_ALL_QUIZZES_WITH_USER_PROGRESS_SQL,
+  getAllQuizzesWithUserProgress,
+  SEARCH_QUIZZES_SQL,
+  searchQuizzes,
+  checkQuizCompletion,
+  getAllRewards,
+  getRewardById,
+  completeQuizAndProcessRewards,
+  unlockReward,
+  getAllResourceCategories,
+  getResourceCategoryById,
+  searchResourceCategories,
+  getAllResourceDocuments,
+  getResourceDocumentById,
+  searchResourceDocuments,
+  getAllFriends,
+  getAllInspirations,
+  createChatSession,
+  getAllChatSessions,
+  getChatSession,
+  updateChatSessionTitle,
+  deleteChatSession,
+  clearChatMessages,
+  addChatMessage,
+  getChatMessages,
+  getChatMessageCount,
+  createDeployment,
+  getDeployment,
+  getDeploymentsByStack,
+  getDeploymentsByUser,
+  updateDeploymentStatus,
+  deleteDeployment,
+  getWorkspaceState,
+  saveWorkspaceState,
+  deleteWorkspaceState,
+  getAllWorkspaceStates,
+  createSkillRun,
+  getSkillRun,
+  getSkillRunsBySlug,
+  getSkillRunsByUser,
+  updateSkillRunStatus,
+  cleanupOrphanedRuns,
+  deleteSkillRun,
+  saveForgeScene,
+  getForgeScene,
+  getForgeScenesByUser,
+  deleteForgeScene,
+  saveForgeIteration,
+  getForgeIterationsByScene,
+  saveForgeMaterialProfile,
+  getForgeMaterialProfiles,
+  deleteForgeMaterialProfile,
+  listBiosignalBridgeConfigs,
+  getBiosignalBridgeConfig,
+  listEnabledBiosignalBridges,
+  setBiosignalBridgeEnabled,
+  reseedDormantBiosignalBridges,
+  listBiosignalProviderConfigs,
+  getBiosignalProviderConfig,
+  listEnabledBiosignalProviders,
+  setBiosignalProviderEnabled,
+  reseedDormantBiosignalProviders,
+  initializeVectorSearch,
+  storeDocumentEmbedding,
+  batchStoreEmbeddings,
+  searchDocumentsByVector,
+  hybridSearchDocuments,
+  findSimilarDocuments,
+  getDocumentsWithoutEmbeddings,
+  getVectorSearchMetrics,
+  upsertConversationEmbedding,
+  retrieveTopKForSession,
+  createSavepoint,
+  rollbackToSavepoint,
+  releaseSavepoint,
+  withSavepoint,
+  saveGenericState,
+  getPgStatIoStats,
+  getPGLiteIndexedDbSize,
+  hybridSearch,
+  getKBStats
+};