@adia-ai/gen-ui 0.8.37

package/retrieval/feedback/dialog-recorder.js

@@ -0,0 +1,107 @@
+const IS_NODE = typeof process !== "undefined" && !!process.versions?.node;
+const ENABLED = IS_NODE && (process?.env?.["ADIA_LOG_DIALOGS"] === "1" || process?.env?.["ADIA_LOG_DIALOGS"] === "true");
+let _fs = null;
+let _path = null;
+let _url = null;
+let _logsRoot = null;
+async function _ensureModules() {
+  if (_fs) return;
+  _fs = await import(
+    /* @vite-ignore */
+    "node:fs/promises"
+  );
+  _path = await import(
+    /* @vite-ignore */
+    "node:path"
+  );
+  _url = await import(
+    /* @vite-ignore */
+    "node:url"
+  );
+  const __dirname = _path.dirname(_url.fileURLToPath(import.meta.url));
+  _logsRoot = _path.resolve(__dirname, "..", "..", "..", "..", "logs", "dialogs");
+}
+const _turnCounter = /* @__PURE__ */ new Map();
+const _sessionMetaWritten = /* @__PURE__ */ new Set();
+async function recordTurn(record) {
+  if (!ENABLED) return null;
+  try {
+    await _ensureModules();
+    const sessionId = record.sessionId ?? `standalone-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+    const turnIdx = _turnCounter.get(sessionId) ?? 0;
+    _turnCounter.set(sessionId, turnIdx + 1);
+    const slug = String(record.intent ?? "turn").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "turn";
+    const rand = Math.random().toString(36).slice(2, 6);
+    const fileName = `${String(turnIdx).padStart(3, "0")}-${slug}-${rand}.json`;
+    const sessionDir = _path.join(_logsRoot, sessionId);
+    await _fs.mkdir(sessionDir, { recursive: true });
+    if (!_sessionMetaWritten.has(sessionId) && turnIdx === 0) {
+      _sessionMetaWritten.add(sessionId);
+      const sessionMeta = {
+        sessionId,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        originIntent: record.intent ?? null,
+        engine: record.engine ?? null,
+        mode: record.mode ?? null,
+        model: record.model ?? null,
+        originAnalysis: record.analysis ? {
+          steelman: record.analysis.steelman ?? null,
+          concepts: record.analysis.concepts ?? [],
+          impliedComponents: record.analysis.impliedComponents ?? [],
+          styleHints: record.analysis.styleHints ?? []
+        } : null
+      };
+      await _fs.writeFile(
+        _path.join(sessionDir, "_session.json"),
+        JSON.stringify(sessionMeta, null, 2) + "\n"
+      );
+    }
+    const payload = {
+      // ── Identity ────────────────────────────────────────────────
+      sessionId,
+      turnIndex: turnIdx,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      isIteration: !!record.isIteration,
+      // ── Request ─────────────────────────────────────────────────
+      intent: record.intent,
+      mode: record.mode ?? null,
+      engine: record.engine ?? null,
+      model: record.model ?? null,
+      currentCanvas: record.currentCanvas ?? null,
+      // ── Pipeline-side reasoning ─────────────────────────────────
+      analysis: record.analysis ?? null,
+      patterns: (record.patterns ?? []).slice(0, 10).map((p) => ({
+        name: p.name,
+        score: p.score ?? p.confidence ?? null,
+        keywords: p.keywords ?? null
+      })),
+      // ── LLM I/O ─────────────────────────────────────────────────
+      systemPrompt: record.systemPrompt ?? null,
+      rawLLMResponse: record.rawLLMResponse ?? null,
+      // ── Result ──────────────────────────────────────────────────
+      messages: record.messages ?? [],
+      validation: record.validation ?? null,
+      drift: record.drift ?? null,
+      suggestions: record.suggestions ?? [],
+      // ── Telemetry ───────────────────────────────────────────────
+      timing: record.timing ?? null,
+      tokens: record.tokens ?? null,
+      engineDebug: record.engineDebug ?? null
+    };
+    const filePath = _path.join(sessionDir, fileName);
+    await _fs.writeFile(filePath, JSON.stringify(payload, null, 2) + "\n");
+    return filePath;
+  } catch (err) {
+    console.warn("[dialog-recorder] failed to record turn:", err.message);
+    return null;
+  }
+}
+function isRecording() {
+  if (ENABLED) return true;
+  const IS_NODE_RT = typeof process !== "undefined" && process.versions?.node;
+  return IS_NODE_RT ? !!process?.env?.["A2UI_COMPOSE_TRACE"] : false;
+}
+export {
+  isRecording,
+  recordTurn
+};

package/retrieval/feedback/feedback-analyzer.js

@@ -0,0 +1,180 @@
+import { feedbackStore } from "./feedback-store.js";
+import { categorizeIntent } from "../intent/intent-categorizer.js";
+let fs = null;
+let path = null;
+const IS_NODE = typeof process !== "undefined" && process.versions?.node;
+if (IS_NODE) {
+  try {
+    fs = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    path = await import(
+      /* @vite-ignore */
+      "node:path"
+    );
+  } catch {
+  }
+}
+const FEEDBACK_DIR = path ? path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "..", "gen-ui/corpus", "feedback") : null;
+class FeedbackAnalyzer {
+  /**
+   * Read JSONL feedback files for the last N days.
+   */
+  async readRange(days = 30) {
+    if (!fs || !FEEDBACK_DIR) return [];
+    const entries = [];
+    const now = /* @__PURE__ */ new Date();
+    const dateStrings = /* @__PURE__ */ new Set();
+    for (let i = 0; i < days; i++) {
+      const d = new Date(now);
+      d.setDate(d.getDate() - i);
+      dateStrings.add(d.toISOString().slice(0, 10));
+    }
+    try {
+      const files = await fs.readdir(FEEDBACK_DIR);
+      const jsonlFiles = files.filter((f) => f.endsWith(".jsonl")).filter((f) => {
+        const dateStr = f.replace(".jsonl", "");
+        return dateStrings.has(dateStr);
+      }).sort();
+      for (const file of jsonlFiles) {
+        try {
+          const content = await fs.readFile(path.join(FEEDBACK_DIR, file), "utf8");
+          const lines = content.trim().split("\n").filter(Boolean);
+          for (const line of lines) {
+            try {
+              const entry = JSON.parse(line);
+              entry["_file"] = file;
+              entries.push(entry);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return entries;
+  }
+  /**
+   * Aggregate feedback entries by intent category.
+   */
+  aggregateByIntent(entries) {
+    const buckets = /* @__PURE__ */ new Map();
+    const executions = entries.filter((e) => e.type === "execution");
+    const ratings = entries.filter((e) => e.type === "rating");
+    const ratingsByExecId = /* @__PURE__ */ new Map();
+    for (const r of ratings) {
+      if (!r.executionId) continue;
+      if (!ratingsByExecId.has(r.executionId)) {
+        ratingsByExecId.set(r.executionId, []);
+      }
+      ratingsByExecId.get(r.executionId).push(r);
+    }
+    for (const exec of executions) {
+      const { category } = categorizeIntent(exec.intent ?? "");
+      if (!buckets.has(category)) {
+        buckets.set(category, {
+          count: 0,
+          totalScore: 0,
+          totalRating: 0,
+          ratingCount: 0,
+          patternMatchCount: 0,
+          entries: [],
+          sampleIntents: []
+        });
+      }
+      const bucket = buckets.get(category);
+      bucket.count++;
+      bucket.totalScore += exec.score ?? 0;
+      bucket.entries.push(exec);
+      if (exec.patternMatch) {
+        bucket.patternMatchCount++;
+      }
+      if (bucket.sampleIntents.length < 5 && exec.intent) {
+        const intentLower = exec.intent.toLowerCase();
+        if (!bucket.sampleIntents.some((s) => s.toLowerCase() === intentLower)) {
+          bucket.sampleIntents.push(exec.intent);
+        }
+      }
+      const execRatings = ratingsByExecId.get(exec.executionId ?? "") ?? [];
+      for (const r of execRatings) {
+        bucket.totalRating += r.rating ?? 0;
+        bucket.ratingCount++;
+      }
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const [category, bucket] of buckets) {
+      result.set(category, {
+        count: bucket.count,
+        avgScore: bucket.count > 0 ? Math.round(bucket.totalScore / bucket.count) : 0,
+        avgRating: bucket.ratingCount > 0 ? Math.round(bucket.totalRating / bucket.ratingCount * 10) / 10 : 0,
+        patternMatchRate: bucket.count > 0 ? Math.round(bucket.patternMatchCount / bucket.count * 100) : 0,
+        sampleIntents: bucket.sampleIntents,
+        entries: bucket.entries
+      });
+    }
+    return result;
+  }
+  /**
+   * Find intent categories with weak performance.
+   */
+  findWeakIntents(aggregated, threshold = 60) {
+    const weak = [];
+    for (const [category, data] of aggregated) {
+      if (data.avgScore < threshold) {
+        weak.push({
+          category,
+          count: data.count,
+          avgScore: data.avgScore,
+          avgRating: data.avgRating,
+          sampleIntents: data.sampleIntents
+        });
+      }
+    }
+    return weak.sort((a, b) => a.avgScore - b.avgScore);
+  }
+  /**
+   * Find intent categories ready for pattern promotion.
+   * Criteria: avgScore >= 95, avgRating >= 4, count >= 3
+   */
+  findPromotionCandidates(aggregated) {
+    const candidates = [];
+    for (const [category, data] of aggregated) {
+      if (data.avgScore >= 95 && data.avgRating >= 4 && data.count >= 3) {
+        candidates.push({
+          category,
+          count: data.count,
+          avgScore: data.avgScore,
+          avgRating: data.avgRating,
+          patternMatchRate: data.patternMatchRate,
+          sampleIntents: data.sampleIntents
+        });
+      }
+    }
+    return candidates.sort((a, b) => b.avgScore - a.avgScore);
+  }
+  /**
+   * Find intent categories with no pattern match AND low scores — gaps in pattern coverage.
+   */
+  findPatternGaps(aggregated) {
+    const gaps = [];
+    for (const [category, data] of aggregated) {
+      if (data.patternMatchRate === 0 && data.avgScore < 70) {
+        gaps.push({
+          category,
+          count: data.count,
+          avgScore: data.avgScore,
+          avgRating: data.avgRating,
+          patternMatchRate: data.patternMatchRate,
+          sampleIntents: data.sampleIntents
+        });
+      }
+    }
+    return gaps.sort((a, b) => a.avgScore - b.avgScore);
+  }
+}
+export {
+  FeedbackAnalyzer,
+  feedbackStore
+};

package/retrieval/feedback/feedback-store.js

@@ -0,0 +1,194 @@
+import { rankWeakDomains, summarizeRatings } from "./human-signal.js";
+let fs = null;
+let path = null;
+const IS_NODE = typeof process !== "undefined" && process.versions?.node;
+if (IS_NODE) {
+  try {
+    fs = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    path = await import(
+      /* @vite-ignore */
+      "node:path"
+    );
+  } catch {
+  }
+}
+function feedbackDir() {
+  if (!path) return null;
+  const override = typeof process !== "undefined" ? process.env?.["A2UI_FEEDBACK_DIR"] : void 0;
+  if (override) return override;
+  return path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "..", "gen-ui/corpus", "feedback");
+}
+function todayFile() {
+  const dir = feedbackDir();
+  if (!path || !dir) return null;
+  const d = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return path.join(dir, `${d}.jsonl`);
+}
+async function append(entry) {
+  const dir = feedbackDir();
+  if (!fs || !dir) return;
+  try {
+    await fs.mkdir(dir, { recursive: true });
+    await fs.appendFile(todayFile(), JSON.stringify(entry) + "\n");
+  } catch (e) {
+    console.warn("FeedbackStore: write failed", e.message);
+  }
+}
+const feedbackStore = {
+  /** Log a completed generation execution. */
+  async logExecution({
+    executionId,
+    intent,
+    model,
+    domain,
+    mode,
+    patternMatch,
+    patternConfidence,
+    score,
+    componentCount,
+    tokenCount,
+    meta
+  }) {
+    await append({
+      type: "execution",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      executionId,
+      intent,
+      model,
+      domain,
+      mode,
+      patternMatch,
+      patternConfidence,
+      score,
+      componentCount,
+      tokenCount,
+      meta: meta ?? null
+    });
+  },
+  /**
+   * Log a user rating (thumbs up / thumbs down).
+   *
+   * The context fields are optional and additive — pre-existing rating lines
+   * without them still parse. Supplying `domain` is what lets human signal
+   * rank weak domains without an execution join (see `human-signal.ts`).
+   */
+  async logRating({ executionId, rating, intent, domain, engine, strategy, score, source, notes }) {
+    await append({
+      type: "rating",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      executionId,
+      rating,
+      intent,
+      ...domain ? { domain } : {},
+      ...engine ? { engine } : {},
+      ...strategy ? { strategy } : {},
+      ...typeof score === "number" ? { score } : {},
+      ...source ? { source } : {},
+      ...notes ? { notes } : {}
+    });
+  },
+  /** Log a pattern save action. */
+  async logPatternSave({ executionId, patternName, intent }) {
+    await append({
+      type: "pattern_save",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      executionId,
+      patternName,
+      intent
+    });
+  },
+  /** Log a training gap identified by LLM meta or heuristics. */
+  async logGap({ type, description, source, executionId }) {
+    await append({
+      type: "gap",
+      gapType: type,
+      // 'pattern' | 'domain' | 'component' | 'prompt'
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      description,
+      source,
+      executionId
+    });
+  },
+  /** Read recent feedback entries (Node only). */
+  async readRecent(limit = 100) {
+    const dir = feedbackDir();
+    if (!fs || !dir) return [];
+    try {
+      const files = (await fs.readdir(dir)).filter((f) => f.endsWith(".jsonl")).sort().reverse();
+      const entries = [];
+      for (const file of files) {
+        if (entries.length >= limit) break;
+        const content = await fs.readFile(path.join(dir, file), "utf8");
+        const lines = content.trim().split("\n").filter(Boolean).reverse();
+        for (const line of lines) {
+          if (entries.length >= limit) break;
+          try {
+            entries.push(JSON.parse(line));
+          } catch {
+          }
+        }
+      }
+      return entries;
+    } catch {
+      return [];
+    }
+  },
+  /** Get gap summary — aggregate gap signals for training improvement. */
+  async getGapSummary() {
+    const entries = await this.readRecent(500);
+    const gaps = entries.filter((e) => e["type"] === "gap");
+    const byType = {};
+    for (const g of gaps) {
+      if (!byType[g.gapType]) byType[g.gapType] = [];
+      byType[g.gapType].push(g.description ?? "");
+    }
+    return byType;
+  },
+  /**
+   * Get quality metrics — aggregate from recent executions and human ratings.
+   *
+   * `thumbUpRate` is a percentage over rating entries alone: it is reported
+   * even when the read window holds no executions, because a rated surface
+   * whose generation happened offline (the gen-UI gallery) has ratings without
+   * matching execution lines. Before gh#668 this method returned early on
+   * `executions === 0` and swallowed those thumbs entirely.
+   */
+  async getQualityMetrics() {
+    const entries = await this.readRecent(500);
+    const executions = entries.filter((e) => e["type"] === "execution");
+    const ratings = summarizeRatings(entries);
+    const domains = rankWeakDomains(entries, { limit: Number.MAX_SAFE_INTEGER });
+    const avgScore = executions.length > 0 ? executions.reduce((s, e) => s + (e.score ?? 0), 0) / executions.length : 0;
+    const avgTokens = executions.length > 0 ? executions.reduce((s, e) => s + (e.tokenCount ?? 0), 0) / executions.length : 0;
+    return {
+      executions: executions.length,
+      avgScore: Math.round(avgScore),
+      avgTokens: Math.round(avgTokens),
+      thumbUpRate: ratings.thumbUpRate,
+      ratings,
+      byDomain: Object.fromEntries(
+        domains.map((d) => [d.domain, {
+          count: d.executions,
+          avgScore: d.selfScore,
+          humanRatings: d.humanRatings,
+          thumbUpRate: d.humanScore
+        }])
+      ),
+      gaps: await this.getGapSummary()
+    };
+  },
+  /**
+   * Rank domains weakest-first, weighing human thumbs above the self-grade.
+   * The rule lives in `human-signal.ts`; this is the store-backed entry point.
+   */
+  async getWeakDomains(limit = 10) {
+    const entries = await this.readRecent(500);
+    return rankWeakDomains(entries, { limit });
+  }
+};
+export {
+  feedbackStore
+};

package/retrieval/feedback/feedback.js

@@ -0,0 +1,117 @@
+class FeedbackCollector {
+  #entries = /* @__PURE__ */ new Map();
+  /**
+   * Initialize a feedback entry from generation results.
+   * Called automatically after each generation completes.
+   */
+  initFromGeneration(executionId, { intent, domain, mode, messages, validation }) {
+    const components = messages?.[0]?.components ?? [];
+    const checks = validation?.checks ?? [];
+    const failedChecks = checks.filter((c) => !c.passed);
+    const structural = failedChecks.some(
+      (c) => ["hasRootComponent", "noOrphanedChildren", "flatAdjacency"].includes(c.name)
+    ) ? 0.5 : 1;
+    const completeness = Math.max(0, 1 - failedChecks.filter((c) => ["textContentSet", "allTypesRegistered"].includes(c.name)).length * 0.1);
+    const idiomatic = failedChecks.some(
+      (c) => ["noBareDivs", "noBareInputs", "cardStructure"].includes(c.name)
+    ) ? 0.5 : 1;
+    const minimal = failedChecks.some(
+      (c) => ["noHardcodedColors", "noInlineLayout"].includes(c.name)
+    ) ? 0.5 : 1;
+    this.#entries.set(executionId, {
+      executionId,
+      intent: intent ?? "",
+      domain: domain ?? "",
+      mode: mode ?? "instant",
+      timestamp: Date.now(),
+      generation: {
+        componentCount: components.length,
+        componentTypes: [...new Set(components.map((c) => c.component).filter((x) => Boolean(x)))],
+        score: validation?.score ?? 0,
+        validationChecks: checks.map((c) => ({ name: c.name, passed: c.passed })),
+        qualityDimensions: { structural, completeness, idiomatic, minimal }
+      },
+      feedback: {},
+      patterns: {}
+    });
+  }
+  /**
+   * Collect user feedback for an execution.
+   */
+  collectFeedback(executionId, feedback) {
+    const entry = this.#entries.get(executionId);
+    if (!entry) {
+      this.#entries.set(executionId, {
+        executionId,
+        intent: "",
+        domain: "",
+        mode: "",
+        timestamp: Date.now(),
+        generation: { componentCount: 0, componentTypes: [], score: 0, validationChecks: [], qualityDimensions: { structural: 0, completeness: 0, idiomatic: 0, minimal: 0 } },
+        feedback: {},
+        patterns: {}
+      });
+    }
+    const e = this.#entries.get(executionId);
+    e.feedback = { ...e.feedback, ...feedback };
+  }
+  /**
+   * Collect pattern-related feedback.
+   */
+  collectPatternFeedback(executionId, patternFeedback) {
+    const entry = this.#entries.get(executionId);
+    if (!entry) return;
+    entry.patterns = { ...entry.patterns, ...patternFeedback };
+  }
+  /**
+   * Get a single feedback entry.
+   */
+  get(executionId) {
+    return this.#entries.get(executionId) ?? null;
+  }
+  /**
+   * Get all feedback entries.
+   */
+  getAll() {
+    return [...this.#entries.values()];
+  }
+  /** Number of entries. */
+  get size() {
+    return this.#entries.size;
+  }
+  /**
+   * Export all feedback as structured JSON.
+   * In browser: triggers a file download.
+   * In Node: returns the JSON string.
+   */
+  exportFeedback() {
+    const data = {
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      entryCount: this.#entries.size,
+      entries: this.getAll()
+    };
+    const json = JSON.stringify(data, null, 2);
+    if (typeof document !== "undefined") {
+      const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const blob = new Blob([json], { type: "application/json" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `gen-ui-feedback-${date}.json`;
+      a.style.display = "none";
+      a.addEventListener("click", (e) => e.stopPropagation());
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+    }
+    return json;
+  }
+  /** Clear all entries. */
+  clear() {
+    this.#entries.clear();
+  }
+}
+export {
+  FeedbackCollector
+};

package/retrieval/feedback/gap-registry.js

@@ -0,0 +1,80 @@
+let fs = null;
+let path = null;
+const IS_NODE = typeof process !== "undefined" && process.versions?.node;
+if (IS_NODE) {
+  try {
+    fs = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    path = await import(
+      /* @vite-ignore */
+      "node:path"
+    );
+  } catch {
+  }
+}
+const REGISTRY_PATH = path ? path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "..", "gen-ui/corpus", "gaps", "registry.json") : null;
+async function loadGaps() {
+  if (!fs || !REGISTRY_PATH) return [];
+  try {
+    const content = await fs.readFile(REGISTRY_PATH, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+async function saveGaps(gaps) {
+  if (!fs || !REGISTRY_PATH) return;
+  const dir = path.dirname(REGISTRY_PATH);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(REGISTRY_PATH, JSON.stringify(gaps, null, 2) + "\n");
+}
+async function addGap(gap) {
+  const gaps = await loadGaps();
+  const existing = gaps.find((g) => g.intentCategory === gap.intentCategory && g.status !== "resolved");
+  if (existing) {
+    existing.sampleCount = gap.sampleCount ?? existing.sampleCount;
+    existing.avgScore = gap.avgScore ?? existing.avgScore;
+    existing.avgRating = gap.avgRating ?? existing.avgRating;
+    existing.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+    const intentSet = /* @__PURE__ */ new Set([...existing.sampleIntents, ...gap.sampleIntents ?? []]);
+    existing.sampleIntents = [...intentSet].slice(0, 10);
+  } else {
+    gaps.push({
+      intentCategory: gap.intentCategory,
+      detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+      sampleCount: gap.sampleCount ?? 0,
+      avgScore: gap.avgScore ?? 0,
+      avgRating: gap.avgRating ?? 0,
+      status: "open",
+      resolution: null,
+      sampleIntents: (gap.sampleIntents ?? []).slice(0, 10)
+    });
+  }
+  await saveGaps(gaps);
+  return gaps;
+}
+async function updateGapStatus(category, status, resolution) {
+  const gaps = await loadGaps();
+  const gap = gaps.find((g) => g.intentCategory === category && g.status !== "resolved");
+  if (!gap) {
+    throw new Error(`No open gap found for category: ${category}`);
+  }
+  gap.status = status;
+  if (resolution) {
+    gap.resolution = resolution;
+  }
+  if (status === "resolved") {
+    gap.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  await saveGaps(gaps);
+  return gap;
+}
+export {
+  addGap,
+  loadGaps,
+  saveGaps,
+  updateGapStatus
+};