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

package/dist/stack-4KWCQQP7.js

@@ -0,0 +1,103 @@
+import {
+  OrchestratorV0,
+  loadStack
+} from "./chunk-STMI72WH.js";
+import {
+  runners
+} from "./chunk-PPFTKJDB.js";
+import "./chunk-KASHT6C5.js";
+import "./chunk-GJWAJAX3.js";
+import "./chunk-VZA2NUH3.js";
+import "./chunk-H3POJCFA.js";
+import "./chunk-KHR7ZYCX.js";
+import "./chunk-QWXPVB2L.js";
+import "./chunk-TSQ3BGLA.js";
+import "./chunk-Q2VI6ICE.js";
+import "./chunk-PWAHFID5.js";
+import "./chunk-Y2EULKA2.js";
+import "./chunk-WU4OTGJE.js";
+import {
+  resolveNode
+} from "./chunk-OCLSAUCD.js";
+import "./chunk-BYXBJQAS.js";
+import "./chunk-BCOQMFKT.js";
+import "./chunk-2WTYE4SW.js";
+import "./chunk-FOXUEYWK.js";
+import "./chunk-EXI3LJVJ.js";
+import "./chunk-QJFKEQHF.js";
+import "./chunk-ZVO47SQV.js";
+import "./chunk-XPJ63Y6T.js";
+import "./chunk-WGBCRNMB.js";
+import "./chunk-3LFMIVJM.js";
+import "./chunk-AFDUOYHD.js";
+import "./chunk-NTMBOESX.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/machines/core/terminal-mapper.ts
+function mapTerminalInputs(terminal, externalInput) {
+  const overrides = {};
+  if (!terminal.terminalInterface?.inputMap) {
+    return overrides;
+  }
+  for (const [externalKey, internalTarget] of Object.entries(terminal.terminalInterface.inputMap)) {
+    if (externalInput[externalKey] !== void 0) {
+      const [nodeId, ...fieldParts] = internalTarget.split(".");
+      const field = fieldParts.join(".");
+      if (!overrides[nodeId]) {
+        overrides[nodeId] = {};
+      }
+      if (field) {
+        overrides[nodeId][field] = externalInput[externalKey];
+      } else {
+      }
+    }
+  }
+  return overrides;
+}
+function mapTerminalOutputs(terminal, nodeOutputs) {
+  const result = {};
+  if (!terminal.terminalInterface?.outputMap) {
+    return result;
+  }
+  for (const [internalSource, externalKey] of Object.entries(
+    terminal.terminalInterface.outputMap
+  )) {
+    const [nodeId, ...fieldParts] = internalSource.split(".");
+    const field = fieldParts.join(".");
+    const output = nodeOutputs.get(nodeId);
+    if (output && field && output[field] !== void 0) {
+      result[externalKey] = output[field];
+    }
+  }
+  return result;
+}
+
+// ../../lib/terminals-tech/machines/core/runners/stack.ts
+async function runInStack(manifest, input, ctx) {
+  const stackRef = manifest.id;
+  const targetStack = await loadStack(stackRef);
+  if (!targetStack) {
+    throw new Error(`StackRunner: target stack not found: ${stackRef}`);
+  }
+  const orchestrator = new OrchestratorV0(resolveNode);
+  try {
+    const configOverrides = mapTerminalInputs(targetStack, input);
+    const subRun = await orchestrator.run(targetStack, {
+      configOverrides,
+      userId: ctx.userId,
+      appletId: ctx.appletId,
+      worldId: ctx.worldId,
+      terminalId: ctx.terminalId
+    });
+    if (!subRun.succeeded || !subRun.outputs) {
+      throw subRun.error || new Error(`Recursive stack execution failed: ${subRun.runId}`);
+    }
+    return mapTerminalOutputs(targetStack, subRun.outputs);
+  } finally {
+    orchestrator.dispose();
+  }
+}
+runners.registerRunner("stack", runInStack);
+export {
+  runInStack
+};

package/dist/storage-L7MWNSPG.js

@@ -0,0 +1,13 @@
+import {
+  deleteDatabaseByDataDir,
+  getStorageEstimate,
+  isStoragePersisted,
+  requestPersistentStorage
+} from "./chunk-3LFMIVJM.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  deleteDatabaseByDataDir,
+  getStorageEstimate,
+  isStoragePersisted,
+  requestPersistentStorage
+};

package/dist/supabaseService-6AYP2VY3.js

@@ -0,0 +1,476 @@
+import {
+  createSupabaseClientComponentClient
+} from "./chunk-QWZRZKLZ.js";
+import {
+  ErrorCodes,
+  SyncError
+} from "./chunk-OSSRZOGC.js";
+import "./chunk-TSQ3BGLA.js";
+import {
+  secureValidate
+} from "./chunk-FOXUEYWK.js";
+import "./chunk-EXI3LJVJ.js";
+import "./chunk-QJFKEQHF.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/utils/network.ts
+function isNavigatorOnline() {
+  try {
+    if (typeof navigator === "undefined") return true;
+    return navigator.onLine;
+  } catch {
+    return true;
+  }
+}
+function withTimeout(p, ms) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error("timeout")), ms);
+    p.then((v) => {
+      clearTimeout(t);
+      resolve(v);
+    }).catch((e) => {
+      clearTimeout(t);
+      reject(e);
+    });
+  });
+}
+var lastSupabaseCheckAt = 0;
+var lastSupabaseReachable = false;
+var MIN_CHECK_INTERVAL_MS = 1e4;
+async function supabaseReachable(ttlMs = 3e4, timeoutMs = 2500) {
+  const now = Date.now();
+  const effectiveTtl = Math.max(ttlMs, MIN_CHECK_INTERVAL_MS);
+  if (now - lastSupabaseCheckAt < effectiveTtl) return lastSupabaseReachable;
+  const base = process.env.NEXT_PUBLIC_SUPABASE_URL || "";
+  if (!base) {
+    lastSupabaseCheckAt = now;
+    lastSupabaseReachable = false;
+    return false;
+  }
+  if (!isNavigatorOnline()) {
+    lastSupabaseCheckAt = now;
+    lastSupabaseReachable = false;
+    return false;
+  }
+  try {
+    const url = base.replace(/\/$/, "") + "/auth/v1/health";
+    const headers = {};
+    const anonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+    if (anonKey) {
+      headers["apikey"] = anonKey;
+      headers["Authorization"] = `Bearer ${anonKey}`;
+    }
+    const resp = await withTimeout(
+      fetch(url, {
+        method: "GET",
+        cache: "no-store",
+        mode: "cors",
+        headers
+      }),
+      timeoutMs
+    );
+    lastSupabaseCheckAt = now;
+    lastSupabaseReachable = resp.ok;
+    return lastSupabaseReachable;
+  } catch {
+    lastSupabaseCheckAt = now;
+    lastSupabaseReachable = false;
+    return false;
+  }
+}
+
+// ../../lib/supabaseService.ts
+var USER_PROFILES_TABLE = "user_profiles";
+var USER_PROGRESS_TABLE = "user_progress";
+var MESH_EVENTS_TABLE = "mesh_events";
+var SUPABASE_MESH_EVENT_SCHEMA = {
+  type: "object",
+  required: ["id", "user_id", "trace_path", "type", "payload", "created_at"],
+  properties: {
+    id: { type: "string" },
+    user_id: { type: "string" },
+    interaction_id: { type: ["string", "null"] },
+    run_id: { type: ["string", "null"] },
+    stack_id: { type: ["string", "null"] },
+    prev_hash: { type: ["string", "null"] },
+    trace_path: { type: "string" },
+    type: { type: "string" },
+    payload: { type: ["object", "array", "string", "number", "boolean", "null"] },
+    metadata: { type: ["object", "null"] },
+    embedding: { type: ["array", "null"], items: { type: "number" } },
+    span: { type: ["array", "null"], items: { type: "number" }, minItems: 2, maxItems: 2 },
+    created_at: { type: "string" }
+  },
+  additionalProperties: true
+};
+function getSupabaseClient() {
+  return createSupabaseClientComponentClient();
+}
+async function ensureReachableOrThrow() {
+  const ok = await supabaseReachable(4e3, 1500);
+  if (!ok) {
+    throw new SyncError("Supabase is unreachable", ErrorCodes.SYNC_OFFLINE, {
+      operation: "ensureReachable"
+    });
+  }
+}
+var singleflight = /* @__PURE__ */ new Map();
+function sf(key, fn) {
+  const existing = singleflight.get(key);
+  if (existing) return existing;
+  const p = fn().finally(() => singleflight.delete(key));
+  singleflight.set(key, p);
+  return p;
+}
+async function getSupabaseUserProgress(userId) {
+  if (!userId) {
+    throw new SyncError(
+      "User ID is required to fetch Supabase user progress",
+      ErrorCodes.SYNC_FAILED,
+      { operation: "getSupabaseUserProgress" }
+    );
+  }
+  return sf(`progress:${userId}`, async () => {
+    try {
+      const supabase = getSupabaseClient();
+      let quizResults = [];
+      let unlockedRewards = [];
+      let claimedRewards = [];
+      await ensureReachableOrThrow();
+      const { data: quizData, error: quizError } = await supabase.from(USER_PROGRESS_TABLE).select("quiz_id, highest_score, completed_at").eq("user_id", userId);
+      if (quizError) {
+        throw new SyncError(
+          `Failed to fetch quiz progress: ${quizError.message}`,
+          ErrorCodes.SYNC_FAILED,
+          { operation: "getQuizProgress", userId, postgrestCode: quizError.code }
+        );
+      } else if (quizData) {
+        quizResults = quizData.map((item) => ({
+          quizId: item.quiz_id,
+          score: item.highest_score || 0,
+          completed: !!item.completed_at
+        }));
+      }
+      const { data: profileData, error: profileError } = await supabase.from(USER_PROFILES_TABLE).select("*").eq("user_id", userId).single();
+      if (profileError && profileError.code !== "PGRST116") {
+        throw new SyncError(
+          `Failed to fetch user profile: ${profileError.message}`,
+          ErrorCodes.SYNC_FAILED,
+          { operation: "getUserProfile", userId, postgrestCode: profileError.code }
+        );
+      } else if (profileError && profileError.code === "PGRST116") {
+        try {
+          const { error: insertErr } = await supabase.from(USER_PROFILES_TABLE).insert({ user_id: userId, preferences: {} }).single();
+          if (insertErr && insertErr.code !== "23505") {
+            throw new SyncError(
+              `Failed to create user profile: ${insertErr.message}`,
+              ErrorCodes.SYNC_FAILED,
+              { operation: "createUserProfile", userId, postgrestCode: insertErr.code }
+            );
+          }
+        } catch (error) {
+          if (error instanceof SyncError) throw error;
+          throw SyncError.fromUnknown(error, "sync");
+        }
+      } else if (profileData && profileData.preferences) {
+        const prefs = profileData.preferences;
+        unlockedRewards = prefs.unlocked_reward_ids || [];
+        claimedRewards = prefs.claimed_reward_ids || [];
+      }
+      return {
+        quizResults,
+        unlockedRewards,
+        claimedRewards,
+        persistenceEnabled: true,
+        preferences: profileData?.preferences || {}
+      };
+    } catch (error) {
+      if (error instanceof SyncError) throw error;
+      throw SyncError.fromUnknown(error, "sync");
+    }
+  });
+}
+async function upsertUserProgressSimple(userId, quizId, score, completedAt) {
+  if (!userId || !quizId) return;
+  try {
+    const supabase = getSupabaseClient();
+    await ensureReachableOrThrow();
+    const ts = completedAt || (/* @__PURE__ */ new Date()).toISOString();
+    const { error } = await supabase.from(USER_PROGRESS_TABLE).upsert({
+      user_id: userId,
+      quiz_id: quizId,
+      highest_score: score,
+      completed_at: ts,
+      last_attempted_at: ts
+    });
+    if (error) {
+      throw new SyncError(
+        `Failed to upsert user progress: ${error.message}`,
+        ErrorCodes.SYNC_FAILED,
+        { operation: "upsertUserProgressSimple", userId, quizId, postgrestCode: error.code }
+      );
+    }
+  } catch (error) {
+    if (error instanceof SyncError) throw error;
+    throw SyncError.fromUnknown(error, "sync");
+  }
+}
+async function saveSupabaseQuizAttempt(userId, quizId, score, allRewardsData) {
+  if (!userId || !quizId) {
+    throw new SyncError("User ID and Quiz ID are required", ErrorCodes.SYNC_FAILED, {
+      operation: "saveSupabaseQuizAttempt"
+    });
+  }
+  try {
+    const supabase = getSupabaseClient();
+    const { data: existingAttempt, error: fetchError } = await supabase.from(USER_PROGRESS_TABLE).select("highest_score").eq("user_id", userId).eq("quiz_id", quizId).single();
+    if (fetchError && fetchError.code !== "PGRST116") {
+      throw new SyncError(
+        `Failed to fetch existing quiz attempt: ${fetchError.message}`,
+        ErrorCodes.SYNC_FAILED,
+        { operation: "fetchExistingAttempt", userId, quizId, postgrestCode: fetchError.code }
+      );
+    }
+    const existingScore = existingAttempt?.highest_score || 0;
+    if (score > existingScore) {
+      const { error: upsertError } = await supabase.from(USER_PROGRESS_TABLE).upsert({
+        user_id: userId,
+        quiz_id: quizId,
+        highest_score: score,
+        completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+        last_attempted_at: (/* @__PURE__ */ new Date()).toISOString()
+        // Add last_attempted_at
+      });
+      if (upsertError) {
+        throw new SyncError(
+          `Failed to upsert quiz attempt: ${upsertError.message}`,
+          ErrorCodes.SYNC_FAILED,
+          { operation: "upsertQuizAttempt", userId, quizId, postgrestCode: upsertError.code }
+        );
+      }
+    } else {
+      const { error: updateError } = await supabase.from(USER_PROGRESS_TABLE).update({ last_attempted_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("user_id", userId).eq("quiz_id", quizId);
+      if (updateError) {
+        throw new SyncError(
+          `Failed to update last_attempted_at: ${updateError.message}`,
+          ErrorCodes.SYNC_FAILED,
+          { operation: "updateLastAttempted", userId, quizId, postgrestCode: updateError.code }
+        );
+      }
+    }
+    const newlyUnlockedRewardIds = [];
+    const { data: currentProfile, error: profileError } = await supabase.from(USER_PROFILES_TABLE).select("preferences, user_id").eq("user_id", userId).single();
+    if (profileError && profileError.code !== "PGRST116") {
+      throw new SyncError(
+        `Failed to fetch user profile for reward processing: ${profileError.message}`,
+        ErrorCodes.SYNC_FAILED,
+        { operation: "fetchProfileForRewards", userId, postgrestCode: profileError.code }
+      );
+    }
+    const currentPreferences = currentProfile?.preferences || {};
+    const currentUnlockedIds = currentPreferences.unlocked_reward_ids || [];
+    const { data: allCompletedQuizData, error: allQuizError } = await supabase.from(USER_PROGRESS_TABLE).select("quiz_id").eq("user_id", userId).not("completed_at", "is", null);
+    if (allQuizError) {
+      throw new SyncError(
+        `Failed to fetch completed quizzes for reward processing: ${allQuizError.message}`,
+        ErrorCodes.SYNC_FAILED,
+        { operation: "fetchCompletedQuizzes", userId, postgrestCode: allQuizError.code }
+      );
+    }
+    const completedQuizIds = new Set((allCompletedQuizData || []).map((q) => q.quiz_id));
+    if (!completedQuizIds.has(quizId) && score > 0) {
+      completedQuizIds.add(quizId);
+    }
+    for (const reward of allRewardsData) {
+      if (reward.unlockRequirement?.type === "quiz" && reward.unlockRequirement.quizId) {
+        if (reward.unlockRequirement.quizId === quizId && !currentUnlockedIds.includes(reward.id)) {
+          newlyUnlockedRewardIds.push(reward.id);
+        }
+      } else if (reward.unlockRequirement?.type === "completion" && reward.unlockRequirement.required_quizzes) {
+        const required = reward.unlockRequirement.required_quizzes;
+        if (required.every((reqQuizId) => completedQuizIds.has(reqQuizId)) && !currentUnlockedIds.includes(reward.id)) {
+          newlyUnlockedRewardIds.push(reward.id);
+        }
+      }
+    }
+    if (newlyUnlockedRewardIds.length > 0) {
+      const updatedUnlockedIds = Array.from(
+        /* @__PURE__ */ new Set([...currentUnlockedIds, ...newlyUnlockedRewardIds])
+      );
+      const newPreferences = {
+        ...currentPreferences,
+        unlocked_reward_ids: updatedUnlockedIds
+      };
+      const { error: updatePrefsError } = await supabase.from(USER_PROFILES_TABLE).update({ preferences: newPreferences }).eq("user_id", userId);
+      if (updatePrefsError) {
+        throw new SyncError(
+          `Failed to update user preferences with new rewards: ${updatePrefsError.message}`,
+          ErrorCodes.SYNC_FAILED,
+          {
+            operation: "updateRewards",
+            userId,
+            rewardIds: newlyUnlockedRewardIds,
+            postgrestCode: updatePrefsError.code
+          }
+        );
+      }
+    }
+    return { newlyUnlockedRewardIds };
+  } catch (error) {
+    if (error instanceof SyncError) throw error;
+    throw SyncError.fromUnknown(error, "sync");
+  }
+}
+async function claimSupabaseReward(userId, rewardId) {
+  if (!userId || !rewardId) {
+    throw new SyncError("User ID and Reward ID are required", ErrorCodes.SYNC_FAILED, {
+      operation: "claimSupabaseReward"
+    });
+  }
+  try {
+    const supabase = getSupabaseClient();
+    const { data: profileData, error: profileError } = await supabase.from(USER_PROFILES_TABLE).select("preferences").eq("user_id", userId).single();
+    if (profileError) {
+      if (profileError.code !== "PGRST116") {
+        throw new SyncError(
+          `Failed to fetch user profile for claiming reward: ${profileError.message}`,
+          ErrorCodes.SYNC_FAILED,
+          { operation: "fetchProfileForClaim", userId, rewardId, postgrestCode: profileError.code }
+        );
+      }
+      try {
+        await supabase.from(USER_PROFILES_TABLE).insert({ user_id: userId, preferences: {} }).single();
+      } catch (error) {
+        throw SyncError.fromUnknown(error, "sync");
+      }
+      return;
+    }
+    const currentPreferences = profileData?.preferences || {};
+    const currentClaimedIds = currentPreferences.claimed_reward_ids || [];
+    const currentUnlockedIds = currentPreferences.unlocked_reward_ids || [];
+    if (currentUnlockedIds.includes(rewardId) && !currentClaimedIds.includes(rewardId)) {
+      const updatedClaimedIds = Array.from(/* @__PURE__ */ new Set([...currentClaimedIds, rewardId]));
+      const newPreferences = {
+        ...currentPreferences,
+        claimed_reward_ids: updatedClaimedIds
+      };
+      const { error: updatePrefsError } = await supabase.from(USER_PROFILES_TABLE).update({ preferences: newPreferences }).eq("user_id", userId);
+      if (updatePrefsError) {
+        throw new SyncError(
+          `Failed to update user preferences with claimed reward: ${updatePrefsError.message}`,
+          ErrorCodes.SYNC_FAILED,
+          {
+            operation: "updateClaimedReward",
+            userId,
+            rewardId,
+            postgrestCode: updatePrefsError.code
+          }
+        );
+      }
+    } else if (!currentUnlockedIds.includes(rewardId)) {
+      throw new SyncError(
+        `Attempted to claim reward that is not unlocked`,
+        ErrorCodes.SYNC_FAILED,
+        { operation: "claimLockedReward", userId, rewardId }
+      );
+    }
+  } catch (error) {
+    if (error instanceof SyncError) throw error;
+    throw SyncError.fromUnknown(error, "sync");
+  }
+}
+async function updateUserPreferences(userId, preferences) {
+  if (!userId) {
+    throw new SyncError("User ID is required to update preferences", ErrorCodes.SYNC_FAILED, {
+      operation: "updateUserPreferences"
+    });
+  }
+  try {
+    const supabase = getSupabaseClient();
+    const { error } = await supabase.from(USER_PROFILES_TABLE).update({ preferences }).eq("user_id", userId);
+    if (error) {
+      throw new SyncError(
+        `Failed to update user preferences: ${error.message}`,
+        ErrorCodes.SYNC_FAILED,
+        { operation: "updateUserPreferences", userId, postgrestCode: error.code }
+      );
+    }
+  } catch (error) {
+    if (error instanceof SyncError) throw error;
+    throw SyncError.fromUnknown(error, "sync");
+  }
+}
+async function appendSupabaseMeshEvent(event) {
+  await ensureReachableOrThrow();
+  const supabase = getSupabaseClient();
+  const { data, error } = await supabase.from(MESH_EVENTS_TABLE).insert(event).select("*").single();
+  if (error || !data) {
+    throw new SyncError(
+      `Failed to insert mesh event: ${error?.message || "Unknown error"}`,
+      ErrorCodes.SYNC_FAILED,
+      { operation: "appendSupabaseMeshEvent", postgrestCode: error?.code }
+    );
+  }
+  const validated = secureValidate(data, SUPABASE_MESH_EVENT_SCHEMA);
+  if (!validated) {
+    throw new SyncError("Supabase mesh event validation failed", ErrorCodes.SYNC_FAILED, {
+      operation: "appendSupabaseMeshEvent"
+    });
+  }
+  return validated;
+}
+async function querySupabaseMeshEvents(userId, interactionId, limit = 200) {
+  await ensureReachableOrThrow();
+  const supabase = getSupabaseClient();
+  let query = supabase.from(MESH_EVENTS_TABLE).select("*").eq("user_id", userId);
+  if (interactionId) {
+    query = query.eq("interaction_id", interactionId);
+  }
+  const { data, error } = await query.order("created_at", { ascending: false }).limit(limit);
+  if (error) {
+    throw new SyncError(`Failed to query mesh events: ${error.message}`, ErrorCodes.SYNC_FAILED, {
+      operation: "querySupabaseMeshEvents",
+      postgrestCode: error.code
+    });
+  }
+  const output = [];
+  for (const row of data || []) {
+    const validated = secureValidate(row, SUPABASE_MESH_EVENT_SCHEMA);
+    if (validated) {
+      output.push(validated);
+    }
+  }
+  return output;
+}
+async function updateSupabaseUserProfileAlias(userId, alias) {
+  if (!userId) {
+    throw new SyncError("User ID is required to update alias", ErrorCodes.SYNC_FAILED, {
+      operation: "updateSupabaseUserProfileAlias"
+    });
+  }
+  try {
+    const supabase = getSupabaseClient();
+    const { error } = await supabase.from(USER_PROFILES_TABLE).update({ username: alias }).eq("user_id", userId);
+    if (error) {
+      throw new SyncError(`Failed to update user alias: ${error.message}`, ErrorCodes.SYNC_FAILED, {
+        operation: "updateUserAlias",
+        userId,
+        alias,
+        postgrestCode: error.code
+      });
+    }
+  } catch (error) {
+    if (error instanceof SyncError) throw error;
+    throw SyncError.fromUnknown(error, "sync");
+  }
+}
+export {
+  appendSupabaseMeshEvent,
+  claimSupabaseReward,
+  getSupabaseUserProgress,
+  querySupabaseMeshEvents,
+  saveSupabaseQuizAttempt,
+  updateSupabaseUserProfileAlias,
+  updateUserPreferences,
+  upsertUserProgressSimple
+};

package/dist/topology-CIWWNVAN.js

@@ -0,0 +1,13 @@
+import {
+  adjacencyMatrix,
+  canonicalizeStack,
+  computeShapeHash,
+  incidenceMatrix
+} from "./chunk-GJWAJAX3.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  adjacencyMatrix,
+  canonicalizeStack,
+  computeShapeHash,
+  incidenceMatrix
+};