@factoredui/core 0.4.1 → 0.5.1

package/README.md

@@ -2,7 +2,7 @@
 
 Capture user interactions, compute behavioral factors, run experiments, and render server-driven UI. Pure TypeScript — no framework dependencies.
 
-Part of the [FactoredUI](https://github.com/jimjrasche/factored-ui) monorepo.
+Part of the [FactoredUI](https://github.com/jjrasche/factoredui) monorepo.
 
 ## Install
 

package/dist/index.cjs

@@ -27,7 +27,9 @@ __export(src_exports, {
   createDataSourceCache: () => createDataSourceCache,
   createEd25519Signer: () => createEd25519Signer,
   createEd25519Verifier: () => createEd25519Verifier,
+  createEventWriter: () => createEventWriter,
   createExperiment: () => createExperiment,
+  createSessionManager: () => createSessionManager,
   createSpecStorage: () => createSpecStorage,
   createWebAdapter: () => createWebAdapter,
   devSignatureVerifier: () => devSignatureVerifier,
@@ -47,10 +49,12 @@ __export(src_exports, {
   queryComponentFactors: () => queryComponentFactors,
   queryExperimentResults: () => queryExperimentResults,
   queryExperimentSummaries: () => queryExperimentSummaries,
+  queryExperimentSummary: () => queryExperimentSummary,
   queryFactorDelta: () => queryFactorDelta,
   queryFactorHistory: () => queryFactorHistory,
   queryFactors: () => queryFactors,
   queryGovernanceLog: () => queryGovernanceLog,
+  queryGovernanceLogByVerdict: () => queryGovernanceLogByVerdict,
   queryRecentGovernanceLog: () => queryRecentGovernanceLog,
   queryUserCluster: () => queryUserCluster,
   resolveAllSources: () => resolveAllSources,
@@ -66,7 +70,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/capture/session.ts
 var DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
-function createSessionManager(supabase, adapter, platform, timeoutMs = DEFAULT_TIMEOUT_MS) {
+function createSessionManager(store, adapter, platform, timeoutMs = DEFAULT_TIMEOUT_MS) {
   let currentSessionId = adapter.loadSessionId();
   let lastActivityAt = Date.now();
   function isSessionExpired() {
@@ -77,9 +81,8 @@ function createSessionManager(supabase, adapter, platform, timeoutMs = DEFAULT_T
       ...adapter.collectSessionMetadata(),
       platform
     };
-    const { data, error } = await supabase.from("sessions").insert({ user_id: userId, metadata }).select("id").single();
-    if (error) throw new Error(`Failed to create session: ${error.message}`);
-    return data.id;
+    const { id } = await store.insertSession(userId, metadata);
+    return id;
   }
   async function ensureSession(userId) {
     lastActivityAt = Date.now();
@@ -92,7 +95,7 @@ function createSessionManager(supabase, adapter, platform, timeoutMs = DEFAULT_T
   }
   async function endSession() {
     if (!currentSessionId) return;
-    await supabase.from("sessions").update({ ended_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", currentSessionId);
+    await store.endSession(currentSessionId);
     currentSessionId = null;
     adapter.clearSessionId();
   }
@@ -105,7 +108,7 @@ function createSessionManager(supabase, adapter, platform, timeoutMs = DEFAULT_T
 // src/capture/writer.ts
 var DEFAULT_FLUSH_INTERVAL_MS = 2e3;
 var DEFAULT_FLUSH_BATCH_SIZE = 50;
-function createEventWriter(supabase, flushIntervalMs = DEFAULT_FLUSH_INTERVAL_MS, flushBatchSize = DEFAULT_FLUSH_BATCH_SIZE, adapter) {
+function createEventWriter(store, flushIntervalMs = DEFAULT_FLUSH_INTERVAL_MS, flushBatchSize = DEFAULT_FLUSH_BATCH_SIZE, adapter) {
   let queue = [];
   let flushTimer = null;
   let isFlushing = false;
@@ -126,12 +129,7 @@ function createEventWriter(supabase, flushIntervalMs = DEFAULT_FLUSH_INTERVAL_MS
     isFlushing = true;
     const batch = queue.splice(0, flushBatchSize);
     try {
-      const { error } = await supabase.from("events").insert(batch);
-      if (error) {
-        queue.unshift(...batch);
-        persistQueueToAdapter();
-        console.error("factoredui: flush failed:", error.message);
-      }
+      await store.insertEvents(batch);
     } catch (err) {
       queue.unshift(...batch);
       persistQueueToAdapter();
@@ -513,18 +511,18 @@ function initCapture(config) {
   const adapter = config.adapter ?? createWebAdapter();
   const platform = config.platform ?? "web";
   const sessionManager = createSessionManager(
-    config.supabase,
+    config.store,
     adapter,
     platform,
     config.sessionTimeoutMs
   );
   const writer = createEventWriter(
-    config.supabase,
+    config.store,
     config.flushIntervalMs,
     config.flushBatchSize
   );
   const enqueueEvent = createEventEnqueuer(
-    config.supabase,
+    config.store,
     sessionManager,
     writer
   );
@@ -553,10 +551,10 @@ function initCapture(config) {
     })
   };
 }
-function createEventEnqueuer(supabase, sessionManager, writer) {
+function createEventEnqueuer(store, sessionManager, writer) {
   let cachedUserId = null;
   return (event) => {
-    resolveUserId(supabase, cachedUserId).then((userId) => {
+    resolveUserId(store, cachedUserId).then((userId) => {
       cachedUserId = userId;
       return sessionManager.ensureSession(userId).then((sessionId) => {
         writer.enqueue(sessionId, userId, event);
@@ -566,43 +564,33 @@ function createEventEnqueuer(supabase, sessionManager, writer) {
     });
   };
 }
-async function resolveUserId(supabase, cachedUserId) {
+async function resolveUserId(store, cachedUserId) {
   if (cachedUserId) return cachedUserId;
-  const { data: { user } } = await supabase.auth.getUser();
-  if (!user) throw new Error("factoredui: user not authenticated");
-  return user.id;
+  const userId = await store.getCurrentUserId();
+  if (!userId) throw new Error("factoredui: user not authenticated");
+  return userId;
 }
 
 // src/factors/query.ts
-async function queryFactors(client, userId, componentPath) {
-  const { data, error } = await client.from("v_factors_current").select("user_id, component_path, factor_name, factor_tier, value, computed_at").eq("user_id", userId).eq("component_path", componentPath);
-  if (error) throw new Error(`queryFactors failed: ${error.message}`);
-  return data;
-}
-async function queryComponentFactors(client, componentPath) {
-  const { data, error } = await client.from("v_component_factors_agg").select(
-    "component_path, factor_name, factor_tier, user_count, avg_value, median_value, p95_value, min_value, max_value, stddev_value"
-  ).eq("component_path", componentPath);
-  if (error) throw new Error(`queryComponentFactors failed: ${error.message}`);
-  return data;
+async function queryFactors(store, userId, componentPath) {
+  return store.queryFactors(userId, componentPath);
+}
+async function queryComponentFactors(store, componentPath) {
+  return store.queryComponentFactors(componentPath);
 }
 
 // src/factors/snapshots.ts
-async function queryFactorHistory(client, userId, componentPath, factorName, since) {
-  const { data, error } = await client.from("factor_snapshots").select("factor_name, factor_tier, value, snapshot_at").eq("user_id", userId).eq("component_path", componentPath).eq("factor_name", factorName).gte("snapshot_at", since.toISOString()).order("snapshot_at", { ascending: true });
-  if (error) throw new Error(`queryFactorHistory failed: ${error.message}`);
-  return data;
-}
-async function queryFactorDelta(client, userId, componentPath, factorName, before, after) {
-  const beforeSnapshot = await findClosestSnapshot(
-    client,
+async function queryFactorHistory(store, userId, componentPath, factorName, since) {
+  return store.queryFactorHistory(userId, componentPath, factorName, since);
+}
+async function queryFactorDelta(store, userId, componentPath, factorName, before, after) {
+  const beforeSnapshot = await store.findClosestSnapshot(
     userId,
     componentPath,
     factorName,
     before
   );
-  const afterSnapshot = await findClosestSnapshot(
-    client,
+  const afterSnapshot = await store.findClosestSnapshot(
     userId,
     componentPath,
     factorName,
@@ -616,28 +604,23 @@ async function queryFactorDelta(client, userId, componentPath, factorName, befor
     delta: afterSnapshot.value - beforeSnapshot.value
   };
 }
-async function findClosestSnapshot(client, userId, componentPath, factorName, targetDate) {
-  const { data, error } = await client.from("factor_snapshots").select("factor_name, factor_tier, value, snapshot_at").eq("user_id", userId).eq("component_path", componentPath).eq("factor_name", factorName).lte("snapshot_at", targetDate.toISOString()).order("snapshot_at", { ascending: false }).limit(1).maybeSingle();
-  if (error) throw new Error(`findClosestSnapshot failed: ${error.message}`);
-  return data;
-}
 
 // src/factors/data-sources.ts
-function factorSource(supabase, userId, componentPath) {
+function factorSource(store, userId, componentPath) {
   return {
-    fetch: () => queryFactors(supabase, userId, componentPath),
+    fetch: () => queryFactors(store, userId, componentPath),
     cache: "local"
   };
 }
-function componentFactorSource(supabase, componentPath) {
+function componentFactorSource(store, componentPath) {
   return {
-    fetch: () => queryComponentFactors(supabase, componentPath),
+    fetch: () => queryComponentFactors(store, componentPath),
     cache: "local"
   };
 }
-function factorHistorySource(supabase, userId, componentPath, factorName, since) {
+function factorHistorySource(store, userId, componentPath, factorName, since) {
   return {
-    fetch: () => queryFactorHistory(supabase, userId, componentPath, factorName, since),
+    fetch: () => queryFactorHistory(store, userId, componentPath, factorName, since),
     cache: "local"
   };
 }
@@ -765,15 +748,11 @@ function buildStatColumn(id, label, valueRef) {
 }
 
 // src/factors/clustering.ts
-async function queryUserCluster(client, userId) {
-  const { data, error } = await client.from("user_clusters").select("user_id, cluster_id, assigned_at").eq("user_id", userId).maybeSingle();
-  if (error) throw new Error(`queryUserCluster failed: ${error.message}`);
-  return data;
+async function queryUserCluster(store, userId) {
+  return store.queryUserCluster(userId);
 }
-async function queryClusterMembers(client, clusterId) {
-  const { data, error } = await client.from("user_clusters").select("user_id, cluster_id, assigned_at").eq("cluster_id", clusterId);
-  if (error) throw new Error(`queryClusterMembers failed: ${error.message}`);
-  return data ?? [];
+async function queryClusterMembers(store, clusterId) {
+  return store.queryClusterMembers(clusterId);
 }
 var MAX_ITERATIONS = 50;
 var CONVERGENCE_THRESHOLD = 1e-6;
@@ -944,91 +923,54 @@ function compareString(value, operator, target) {
 }
 
 // src/experiment/flags.ts
-async function evaluateFlag(supabase, experimentName, platform, deviceMetadata) {
-  const userId = await resolveUserId2(supabase);
+async function evaluateFlag(store, experimentName, platform, deviceMetadata) {
+  const userId = await store.getCurrentUserId();
   if (!userId) return null;
-  const existingAssignment = await fetchAssignment(supabase, userId, experimentName);
+  const existingAssignment = await store.getAssignment(userId, experimentName);
   if (existingAssignment) {
-    await recordExposure(supabase, userId, existingAssignment);
+    await store.recordExposure(userId, existingAssignment.experiment_id, existingAssignment.variant_key);
     return existingAssignment;
   }
-  const newAssignment = await assignToExperiment(supabase, userId, experimentName, platform, deviceMetadata);
+  const newAssignment = await assignToExperiment(store, userId, experimentName, platform, deviceMetadata);
   if (newAssignment) {
-    await recordExposure(supabase, userId, newAssignment);
+    await store.recordExposure(userId, newAssignment.experiment_id, newAssignment.variant_key);
   }
   return newAssignment;
 }
-async function resolveUserId2(supabase) {
-  const { data: { user } } = await supabase.auth.getUser();
-  return user?.id ?? null;
-}
-async function fetchAssignment(supabase, userId, experimentName) {
-  const { data, error } = await supabase.from("experiment_assignments").select(`
-      experiment_id,
-      variant_key,
-      experiments!inner ( name, status ),
-      experiment_variants!inner ( config )
-    `).eq("user_id", userId).eq("experiments.name", experimentName).eq("experiments.status", "running").maybeSingle();
-  if (error || !data) return null;
-  const row = data;
-  return {
-    experiment_id: row.experiment_id,
-    variant_key: row.variant_key,
-    config: row.experiment_variants?.config ?? {}
-  };
-}
-async function assignToExperiment(supabase, userId, experimentName, platform, deviceMetadata) {
-  const experiment = await fetchRunningExperiment(supabase, experimentName, platform);
+async function assignToExperiment(store, userId, experimentName, platform, deviceMetadata) {
+  const experiment = await store.getRunningExperiment(experimentName);
   if (!experiment) return null;
-  const hasConflict = await hasConflictingAssignment(
-    supabase,
+  if (platform && experiment.platforms.length > 0 && !experiment.platforms.includes(platform)) {
+    return null;
+  }
+  const hasConflict = await store.hasConflictingAssignment(
     userId,
     experiment.component_path,
     experiment.id
   );
   if (hasConflict) return null;
-  const isTargeted = await checkTargeting(supabase, userId, experiment, deviceMetadata);
+  const isTargeted = await checkTargeting(store, userId, experiment, deviceMetadata);
   if (!isTargeted) return null;
-  const variants = await fetchExperimentVariants(supabase, experiment.id);
+  const variants = await store.getVariants(experiment.id);
   if (variants.length === 0) return null;
   const selectedVariant = selectVariantByHash(userId, experiment.id, variants);
   if (!selectedVariant) return null;
-  const { error } = await supabase.from("experiment_assignments").insert({
-    user_id: userId,
-    experiment_id: experiment.id,
-    variant_key: selectedVariant.variant_key
-  });
-  if (error) return null;
+  try {
+    await store.writeAssignment(userId, experiment.id, selectedVariant.variant_key);
+  } catch {
+    return null;
+  }
   return {
     experiment_id: experiment.id,
     variant_key: selectedVariant.variant_key,
     config: selectedVariant.config
   };
 }
-async function hasConflictingAssignment(supabase, userId, componentPath, currentExperimentId) {
-  const { data, error } = await supabase.from("experiment_assignments").select("experiment_id, experiments!inner ( id, status, component_path )").eq("user_id", userId).eq("experiments.status", "running").eq("experiments.component_path", componentPath).neq("experiment_id", currentExperimentId).limit(1);
-  if (error) return false;
-  return (data?.length ?? 0) > 0;
-}
-async function fetchRunningExperiment(supabase, experimentName, platform) {
-  const { data, error } = await supabase.from("experiments").select("id, name, component_path, targeting_rules, platforms").eq("name", experimentName).eq("status", "running").maybeSingle();
-  if (error || !data) return null;
-  const experiment = data;
-  if (platform && experiment.platforms.length > 0 && !experiment.platforms.includes(platform)) {
-    return null;
-  }
-  return experiment;
-}
-async function checkTargeting(supabase, userId, experiment, deviceMetadata) {
+async function checkTargeting(store, userId, experiment, deviceMetadata) {
   if (!experiment.targeting_rules || experiment.targeting_rules.length === 0) return true;
-  const factors = await queryFactors(supabase, userId, experiment.component_path);
+  const factors = await queryFactors(store, userId, experiment.component_path);
   return evaluateTargeting(factors, experiment.targeting_rules, deviceMetadata);
 }
-async function fetchExperimentVariants(supabase, experimentId) {
-  const { data, error } = await supabase.from("experiment_variants").select("variant_key, config, traffic_percentage").eq("experiment_id", experimentId).order("variant_key");
-  if (error || !data) return [];
-  return data;
-}
 function selectVariantByHash(userId, experimentId, variants) {
   const hashValue = simpleHash(`${userId}:${experimentId}`);
   const bucket = hashValue % 100;
@@ -1048,27 +990,22 @@ function simpleHash(input) {
   }
   return hash;
 }
-async function recordExposure(supabase, userId, assignment) {
-  await supabase.from("experiment_exposures").insert({
-    user_id: userId,
-    experiment_id: assignment.experiment_id,
-    variant_key: assignment.variant_key
-  });
-}
 
 // src/experiment/lifecycle.ts
-async function createExperiment(client, definition) {
+async function createExperiment(store, definition) {
   validateDefinition(definition);
-  const experiment = await insertExperiment(client, definition);
-  await insertVariants(client, experiment.id, definition.variants);
+  const experiment = await store.insertExperiment({
+    name: definition.name,
+    description: definition.description ?? null,
+    component_path: definition.component_path,
+    targeting_rules: definition.targeting_rules ?? [],
+    platforms: definition.platforms ?? []
+  });
+  await store.insertVariants(experiment.id, definition.variants);
   return experiment;
 }
-async function startExperiment(client, experimentId) {
-  const { data, error } = await client.from("experiments").update({ status: "running" }).eq("id", experimentId).eq("status", "draft").select("id");
-  if (error) throw new Error(`startExperiment failed: ${error.message}`);
-  if (!data || data.length === 0) {
-    throw new Error(`startExperiment: experiment ${experimentId} not found or not in draft status`);
-  }
+async function startExperiment(store, experimentId) {
+  await store.startExperiment(experimentId);
 }
 function validateDefinition(definition) {
   if (definition.variants.length < 2) {
@@ -1083,41 +1020,20 @@ function validateDefinition(definition) {
     throw new Error(`Traffic percentages must sum to 100, got ${totalTraffic}`);
   }
 }
-async function insertExperiment(client, definition) {
-  const { data, error } = await client.from("experiments").insert({
-    name: definition.name,
-    description: definition.description ?? null,
-    component_path: definition.component_path,
-    targeting_rules: definition.targeting_rules ?? [],
-    platforms: definition.platforms ?? []
-  }).select("id, name, status, component_path").single();
-  if (error) throw new Error(`insertExperiment failed: ${error.message}`);
-  return data;
-}
-async function insertVariants(client, experimentId, variants) {
-  const rows = variants.map((v) => ({
-    experiment_id: experimentId,
-    variant_key: v.variant_key,
-    config: v.config,
-    traffic_percentage: v.traffic_percentage
-  }));
-  const { error } = await client.from("experiment_variants").insert(rows);
-  if (error) throw new Error(`insertVariants failed: ${error.message}`);
-}
 
 // src/experiment/results.ts
-async function queryExperimentResults(client, experimentId, factorNames) {
-  const experiment = await fetchExperiment(client, experimentId);
-  if (!experiment) return [];
-  const variantGroups = await fetchAssignmentsByVariant(client, experimentId);
+async function queryExperimentResults(store, experimentId, factorNames) {
+  const meta = await store.getExperimentMeta(experimentId);
+  if (!meta) return [];
+  const variantGroups = await store.getAssignmentsByVariant(experimentId);
   const results = [];
   for (const [variantKey, userIds] of variantGroups) {
     const factorDeltas = await computeVariantDeltas(
-      client,
+      store,
       userIds,
-      experiment.component_path,
+      meta.component_path,
       factorNames,
-      experiment.created_at
+      meta.created_at
     );
     results.push({
       variant_key: variantKey,
@@ -1127,35 +1043,17 @@ async function queryExperimentResults(client, experimentId, factorNames) {
   }
   return results;
 }
-async function fetchExperiment(client, experimentId) {
-  const { data, error } = await client.from("experiments").select("component_path, created_at").eq("id", experimentId).maybeSingle();
-  if (error || !data) return null;
-  return data;
-}
-async function fetchAssignmentsByVariant(client, experimentId) {
-  const { data, error } = await client.from("experiment_assignments").select("variant_key, user_id").eq("experiment_id", experimentId);
-  if (error || !data) return /* @__PURE__ */ new Map();
-  const groups = /* @__PURE__ */ new Map();
-  for (const row of data) {
-    const existing = groups.get(row.variant_key) ?? [];
-    existing.push(row.user_id);
-    groups.set(row.variant_key, existing);
-  }
-  return groups;
-}
-async function computeVariantDeltas(client, userIds, componentPath, factorNames, experimentCreatedAt) {
+async function computeVariantDeltas(store, userIds, componentPath, factorNames, experimentCreatedAt) {
   const beforeDate = new Date(experimentCreatedAt);
   const afterDate = /* @__PURE__ */ new Date();
-  const { data, error } = await client.rpc("bulk_factor_deltas", {
-    p_user_ids: userIds,
-    p_component: componentPath,
-    p_factor_names: factorNames,
-    p_before: beforeDate.toISOString(),
-    p_after: afterDate.toISOString()
-  });
-  if (error) throw new Error(`bulk_factor_deltas failed: ${error.message}`);
-  if (!data) return [];
-  return data.map((row) => ({
+  const rows = await store.bulkFactorDeltas(
+    userIds,
+    componentPath,
+    factorNames,
+    beforeDate.toISOString(),
+    afterDate.toISOString()
+  );
+  return rows.map((row) => ({
     factor_name: row.factor_name,
     before: row.avg_before,
     after: row.avg_after,
@@ -1164,30 +1062,15 @@ async function computeVariantDeltas(client, userIds, componentPath, factorNames,
 }
 
 // src/experiment/governance.ts
-async function evaluateExperimentThresholds(client, experimentId, factorNames) {
-  const componentPath = await fetchExperimentComponentPath(client, experimentId);
-  if (!componentPath) return buildEmptyVerdict();
-  const results = await queryExperimentResults(client, experimentId, factorNames);
-  const thresholds = await fetchThresholds(client, factorNames, componentPath);
+async function evaluateExperimentThresholds(store, experimentId, factorNames) {
+  const meta = await store.getExperimentMeta(experimentId);
+  if (!meta) return buildEmptyVerdict();
+  const results = await queryExperimentResults(store, experimentId, factorNames);
+  const thresholds = await store.queryThresholds(factorNames, meta.component_path);
   return computeGovernanceVerdict(results, thresholds);
 }
-async function concludeExperiment(client, experimentId, winningVariant) {
-  const { error } = await client.from("experiments").update({
-    status: "concluded",
-    concluded_at: (/* @__PURE__ */ new Date()).toISOString(),
-    winning_variant: winningVariant
-  }).eq("id", experimentId).eq("status", "running");
-  if (error) throw new Error(`concludeExperiment failed: ${error.message}`);
-}
-async function fetchExperimentComponentPath(client, experimentId) {
-  const { data, error } = await client.from("experiments").select("component_path").eq("id", experimentId).maybeSingle();
-  if (error || !data) return null;
-  return data.component_path;
-}
-async function fetchThresholds(client, factorNames, componentPath) {
-  const { data, error } = await client.from("thresholds").select("id, factor_name, component_path, operator, value, action").in("factor_name", factorNames).or(`component_path.eq.${componentPath},component_path.is.null`);
-  if (error) throw new Error(`fetchThresholds failed: ${error.message}`);
-  return data ?? [];
+async function concludeExperiment(store, experimentId, winningVariant) {
+  await store.concludeExperiment(experimentId, winningVariant);
 }
 function computeGovernanceVerdict(results, thresholds) {
   if (results.length < 2 || thresholds.length === 0) return buildEmptyVerdict();
@@ -1268,63 +1151,43 @@ function buildEmptyVerdict() {
 }
 
 // src/experiment/governance-check.ts
-async function logGovernanceVerdict(client, experimentId, verdict) {
-  const { error } = await client.from("governance_log").insert({
-    experiment_id: experimentId,
-    verdict: verdict.action,
-    winning_variant: verdict.winning_variant,
-    factor_verdicts: verdict.factor_verdicts
-  });
-  if (error) throw new Error(`logGovernanceVerdict failed: ${error.message}`);
+async function logGovernanceVerdict(store, experimentId, verdict) {
+  await store.insertGovernanceVerdict(
+    experimentId,
+    verdict.action,
+    verdict.winning_variant,
+    verdict.factor_verdicts
+  );
 }
-async function runGovernanceCheck(client, experimentId, factorNames) {
-  const verdict = await evaluateExperimentThresholds(client, experimentId, factorNames);
-  await logGovernanceVerdict(client, experimentId, verdict);
-  await concludeIfWinner(client, experimentId, verdict);
+async function runGovernanceCheck(store, experimentId, factorNames) {
+  const verdict = await evaluateExperimentThresholds(store, experimentId, factorNames);
+  await logGovernanceVerdict(store, experimentId, verdict);
+  await concludeIfWinner(store, experimentId, verdict);
   return verdict;
 }
-async function concludeIfWinner(client, experimentId, verdict) {
+async function concludeIfWinner(store, experimentId, verdict) {
   if (verdict.action === "conclude" && verdict.winning_variant) {
-    await concludeExperiment(client, experimentId, verdict.winning_variant);
+    await concludeExperiment(store, experimentId, verdict.winning_variant);
   }
 }
 
 // src/experiment/dashboard.ts
-async function queryExperimentSummaries(client, filters) {
-  let query = client.from("v_experiment_summary").select("*");
-  query = applyFilters(query, filters);
-  const { data, error } = await query;
-  if (error) throw new Error(`queryExperimentSummaries failed: ${error.message}`);
-  return data ?? [];
+async function queryExperimentSummaries(store, filters) {
+  return store.queryExperimentSummaries(filters);
 }
-function applyFilters(query, filters) {
-  if (!filters) return query;
-  if (filters.status) {
-    query = query.eq("status", filters.status);
-  }
-  if (filters.component_path) {
-    query = query.eq("component_path", filters.component_path);
-  }
-  if (filters.created_after) {
-    query = query.gte("created_at", filters.created_after);
-  }
-  if (filters.created_before) {
-    query = query.lte("created_at", filters.created_before);
-  }
-  return query;
+async function queryExperimentSummary(store, experimentId) {
+  return store.queryExperimentSummary(experimentId);
 }
 
 // src/experiment/governance-log.ts
-var GOVERNANCE_LOG_COLUMNS = "id, experiment_id, verdict, winning_variant, factor_verdicts, evaluated_at";
-async function queryGovernanceLog(client, experimentId) {
-  const { data, error } = await client.from("governance_log").select(GOVERNANCE_LOG_COLUMNS).eq("experiment_id", experimentId).order("evaluated_at", { ascending: false });
-  if (error) throw new Error(`queryGovernanceLog failed: ${error.message}`);
-  return data ?? [];
+async function queryGovernanceLog(store, experimentId) {
+  return store.queryGovernanceLog(experimentId);
 }
-async function queryRecentGovernanceLog(client, limit = 50) {
-  const { data, error } = await client.from("governance_log").select(GOVERNANCE_LOG_COLUMNS).order("evaluated_at", { ascending: false }).limit(limit);
-  if (error) throw new Error(`queryRecentGovernanceLog failed: ${error.message}`);
-  return data ?? [];
+async function queryRecentGovernanceLog(store, limit = 50) {
+  return store.queryRecentGovernanceLog(limit);
+}
+async function queryGovernanceLogByVerdict(store, verdict) {
+  return store.queryGovernanceLogByVerdict(verdict);
 }
 
 // src/sdui/spec-validator.ts
@@ -1551,8 +1414,8 @@ function dispatchAction(actionRef, registry, context) {
 }
 
 // src/sdui/spec-loader.ts
-async function loadSpec(supabase, platform, baseline, storage, verifier) {
-  const remote = await fetchRemoteSpec(supabase, platform);
+async function loadSpec(store, platform, baseline, storage, verifier) {
+  const remote = await fetchRemoteSpec(store, platform);
   if (remote) {
     const validated = await validateSignedSpec(remote, verifier);
     if (validated) {
@@ -1582,28 +1445,13 @@ async function verifySpecHash(signed, verifier) {
   const computedHash = await verifier.computeHash(signed.spec);
   return computedHash === signed.spec_hash;
 }
-async function fetchRemoteSpec(supabase, platform) {
+async function fetchRemoteSpec(store, platform) {
   try {
-    const { data, error } = await supabase.from("ui_active").select("spec_id, ui_specs(*)").eq("platform", platform).single();
-    if (error || !data) return null;
-    return mapRowToSignedSpec(data);
+    return await store.loadActiveSpec(platform);
   } catch {
     return null;
   }
 }
-function mapRowToSignedSpec(data) {
-  const row = data;
-  return {
-    spec: {
-      spec_version: row.ui_specs.spec_version,
-      renderer_min: row.ui_specs.renderer_min,
-      root: row.ui_specs.component_tree
-    },
-    signature: row.ui_specs.signature,
-    signed_at: "",
-    spec_hash: row.ui_specs.spec_hash
-  };
-}
 async function loadActiveSpec(storage) {
   try {
     return await storage.loadActive();
@@ -1754,7 +1602,9 @@ function bytesToHex(bytes) {
   createDataSourceCache,
   createEd25519Signer,
   createEd25519Verifier,
+  createEventWriter,
   createExperiment,
+  createSessionManager,
   createSpecStorage,
   createWebAdapter,
   devSignatureVerifier,
@@ -1774,10 +1624,12 @@ function bytesToHex(bytes) {
   queryComponentFactors,
   queryExperimentResults,
   queryExperimentSummaries,
+  queryExperimentSummary,
   queryFactorDelta,
   queryFactorHistory,
   queryFactors,
   queryGovernanceLog,
+  queryGovernanceLogByVerdict,
   queryRecentGovernanceLog,
   queryUserCluster,
   resolveAllSources,