@oscharko-dev/keiko 0.2.0-beta.7 → 0.2.0-beta.9

package/node_modules/@oscharko-dev/keiko-server/dist/memory-maintenance-handlers.js

@@ -6,8 +6,10 @@
 //   2. Run consolidation on the accepted subset; persist auto-applicable relationship edges and
 //      return unresolved review items for MemoriaViva or CLI operators. Conflict and merge review
 //      items are NEVER auto-applied here.
-//   3. Compute the maintenance plan and apply it: promote (-> accepted), reinforce / decay
-//      (confidence patch), archive (-> archived), forget (vault delete + tombstone + reason).
+//   3. Compute the maintenance plan and apply it: promote (-> accepted), archive (-> archived),
+//      forget (vault delete + tombstone + reason). Confidence is immutable provenance and is never
+//      patched here (O-V2): reuse strengthens memories live in retrieval ranking, and disuse-decay
+//      is computed on the fly via the strength curve that gates archive/forget.
 //   4. Emit one audit event per applied effect and return the counts.
 //
 // CSRF: the server dispatch layer enforces x-keiko-csrf for POST, so this route is guarded without
@@ -21,8 +23,6 @@ import { recordMemoryAudit } from "./memory-audit-handler.js";
 function emptyCounts() {
     return {
         promoted: 0,
-        reinforced: 0,
-        decayed: 0,
         archived: 0,
         forgotten: 0,
         superseded: 0,
@@ -44,24 +44,20 @@ function resolveVault(deps) {
     }
     return deps.memoryVault;
 }
-function emitAudit(evidenceStore, kind, surface, summary, extra) {
+function emitAudit(evidenceStore, nowMs, kind, surface, summary, extra) {
     if (evidenceStore === undefined)
         return;
     const event = {
         schemaVersion: "1",
         kind,
         eventId: randomUUID(),
-        occurredAt: Date.now(),
+        occurredAt: nowMs,
         initiatorSurface: surface,
         summary,
         ...extra,
     };
     recordMemoryAudit({ evidenceStore }, event);
 }
-// Patch a record's confidence by rebuilding the provenance envelope (confidence lives there).
-function patchConfidence(vault, record, confidence) {
-    vault.updateMemory(record.id, { provenance: { ...record.provenance, confidence } }, Date.now());
-}
 function recordsById(records) {
     const map = new Map();
     for (const record of records)
@@ -82,9 +78,9 @@ function applyEdges(vault, edges) {
     }
     return created;
 }
-function runConsolidationPass(vault, records, counts) {
+function runConsolidationPass(vault, nowMs, records, counts) {
     const result = runConsolidation(records, {
-        nowMs: Date.now(),
+        nowMs,
         newEdgeId: () => randomUUID(),
         newReviewItemId: () => randomUUID(),
     });
@@ -94,48 +90,41 @@ function runConsolidationPass(vault, records, counts) {
     counts.reviewItems.push(...result.reviewItems);
 }
 // ─── Plan application ──────────────────────────────────────────────────────────
-// Applies the reinforce / decay / archive / forget effects on the post-consolidation snapshot.
-// Promotions are applied SEPARATELY and BEFORE consolidation (see runMemoryMaintenance) so that
-// freshly-accepted memories are visible to conflict detection within the same maintenance pass.
-function applyDecayEffects(vault, evidenceStore, plan, byId, counts) {
-    applyConfidencePatches(vault, plan.reinforce, byId, (n) => (counts.reinforced += n));
-    applyConfidencePatches(vault, plan.decay, byId, (n) => (counts.decayed += n));
-    applyArchives(vault, evidenceStore, plan.archive, byId, counts);
-    applyForgets(vault, evidenceStore, plan.forget, byId, counts);
-}
-function applyPromotions(vault, evidenceStore, ids, byId, counts) {
+// Applies the archive / forget effects on the post-consolidation snapshot. Promotions are applied
+// SEPARATELY and BEFORE consolidation (see runMemoryMaintenance) so that freshly-accepted memories
+// are visible to conflict detection within the same maintenance pass.
+//
+// Confidence is NEVER mutated here (#204, O-V2): reinforcement-on-reuse is realised live in
+// retrieval ranking, and disuse-decay is computed on the fly via the strength curve that already
+// gates archive/forget — so provenance stays intact and every run is idempotent.
+function applyFadeEffects(vault, evidenceStore, nowMs, plan, byId, counts) {
+    applyArchives(vault, evidenceStore, nowMs, plan.archive, byId, counts);
+    applyForgets(vault, evidenceStore, nowMs, plan.forget, byId, counts);
+}
+function applyPromotions(vault, evidenceStore, nowMs, ids, byId, counts) {
     for (const id of ids) {
         const record = byId.get(id);
         if (record === undefined)
             continue;
-        vault.updateMemory(id, { status: "accepted" }, Date.now());
+        vault.updateMemory(id, { status: "accepted" }, nowMs);
         counts.promoted += 1;
-        emitAudit(evidenceStore, "memory:accepted", "memory-center", "Promoted a strong proposed memory.", { memoryId: id, scope: record.scope });
-    }
-}
-function applyConfidencePatches(vault, patches, byId, bump) {
-    for (const patch of patches) {
-        const record = byId.get(patch.id);
-        if (record === undefined)
-            continue;
-        patchConfidence(vault, record, patch.confidence);
-        bump(1);
+        emitAudit(evidenceStore, nowMs, "memory:accepted", "memory-center", "Promoted a strong proposed memory.", { memoryId: id, scope: record.scope });
     }
 }
-function applyArchives(vault, evidenceStore, ids, byId, counts) {
+function applyArchives(vault, evidenceStore, nowMs, ids, byId, counts) {
     for (const id of ids) {
         const record = byId.get(id);
         if (record === undefined)
             continue;
-        vault.updateMemory(id, { status: "archived" }, Date.now());
+        vault.updateMemory(id, { status: "archived" }, nowMs);
         counts.archived += 1;
-        emitAudit(evidenceStore, "memory:archived", "retention", "Archived a faded memory.", {
+        emitAudit(evidenceStore, nowMs, "memory:archived", "retention", "Archived a faded memory.", {
             memoryId: id,
             scope: record.scope,
         });
     }
 }
-function applyForgets(vault, evidenceStore, forgets, byId, counts) {
+function applyForgets(vault, evidenceStore, nowMs, forgets, byId, counts) {
     for (const forget of forgets) {
         const record = byId.get(forget.id);
         if (record === undefined)
@@ -144,20 +133,21 @@ function applyForgets(vault, evidenceStore, forgets, byId, counts) {
             tombstone: true,
             forgetterSurface: "memory-maintenance",
             reason: forget.reason,
-            nowMs: Date.now(),
+            nowMs,
         });
         counts.forgotten += 1;
-        emitAudit(evidenceStore, "memory:forgotten", "retention", `Forgot a memory (${forget.reason}).`, {
+        emitAudit(evidenceStore, nowMs, "memory:forgotten", "retention", `Forgot a memory (${forget.reason}).`, {
             memoryId: forget.id,
             scope: record.scope,
             tombstoned: true,
         });
     }
 }
-// Reusable maintenance core. Drives consolidation + the governance plan against a vault, emitting
-// audit events when an evidence store is supplied. Exported so both the BFF route handler and the
-// `keiko memory maintain` CLI run the SAME pass — no duplicated orchestration.
-export function runMemoryMaintenance(vault, evidenceStore) {
+export function runMemoryMaintenance(vault, evidenceStore, options) {
+    // ONE clock for the whole pass: both plan phases and every vault write / audit timestamp use the
+    // same nowMs, so selection is consistent within a run and fully replay-stable when nowMs is
+    // injected (the deterministic-verification invariant the rest of the stack honours).
+    const nowMs = options?.nowMs ?? Date.now();
     const counts = emptyCounts();
     // Phase 1 — promote strong `proposed` memories FIRST. Consolidation and conflict detection only
     // inspect `accepted` records, so without this a vault full of freshly-captured `proposed`
@@ -165,22 +155,54 @@ export function runMemoryMaintenance(vault, evidenceStore) {
     // resolved. Promoting up front makes a single "Run maintenance" fully effective.
     const beforePromote = vault.listMemories({ includeExpired: true });
     const promoteStats = vault.getAccessStats();
-    const promotePlan = planMemoryMaintenance(beforePromote, promoteStats, { nowMs: Date.now() });
-    applyPromotions(vault, evidenceStore, promotePlan.promote, recordsById(beforePromote), counts);
+    const promotePlan = planMemoryMaintenance(beforePromote, promoteStats, { nowMs });
+    applyPromotions(vault, evidenceStore, nowMs, promotePlan.promote, recordsById(beforePromote), counts);
     // Phase 2 — consolidate the now-accepted set: link safe near-duplicate metadata and surface
     // conflicts / merges as explicit review items. Status mutations require a later governed review.
     const accepted = vault
         .listMemories({ includeExpired: true })
         .filter((record) => record.status === "accepted");
-    runConsolidationPass(vault, accepted, counts);
-    // Phase 3 — reinforce / decay / archive / forget on the post-consolidation snapshot. The access
-    // stats feed the strength model.
+    runConsolidationPass(vault, nowMs, accepted, counts);
+    // Phase 3 — archive / forget on the post-consolidation snapshot. The access stats feed the
+    // strength model; confidence itself is never mutated (O-V2).
     const all = vault.listMemories({ includeExpired: true });
     const accessStats = vault.getAccessStats();
-    const plan = planMemoryMaintenance(all, accessStats, { nowMs: Date.now() });
-    applyDecayEffects(vault, evidenceStore, plan, recordsById(all), counts);
+    const plan = planMemoryMaintenance(all, accessStats, { nowMs });
+    applyFadeEffects(vault, evidenceStore, nowMs, plan, recordsById(all), counts);
     return counts;
 }
+// ─── Bounded autonomous maintenance (#204, O-V4) ───────────────────────────────
+// The strength/decay/forget pass only "lives" if it actually runs. Rather than a free-running
+// background loop (forbidden by the no-unbounded-hidden-activity invariant), maintenance is fired
+// opportunistically — once memory is used — and rate-limited to at most once per interval. The pass
+// itself is already bounded (maxForgetPerRun) and audited, so an autonomous fire is governed.
+export const MEMORY_AUTO_MAINTENANCE_MIN_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+// Pure: due iff never run, or the interval has elapsed. A non-finite/negative interval is treated as
+// "never auto-run" so a misconfiguration can only DISABLE, never spin.
+export function isMaintenanceDue(lastRunAtMs, nowMs, minIntervalMs = MEMORY_AUTO_MAINTENANCE_MIN_INTERVAL_MS) {
+    if (!Number.isFinite(minIntervalMs) || minIntervalMs <= 0)
+        return false;
+    if (lastRunAtMs === undefined)
+        return true;
+    return nowMs - lastRunAtMs >= minIntervalMs;
+}
+// Runs ONE bounded maintenance pass iff enabled AND due, advancing the cursor BEFORE running so a
+// re-entrant call within the same tick cannot double-fire. Returns the result, or null when skipped.
+// Never throws: a maintenance fault must not break the caller (e.g. a chat turn); it is swallowed
+// after advancing the cursor so a persistently-failing pass cannot hot-loop.
+export function maybeRunAutoMaintenance(vault, evidenceStore, state, options) {
+    if (!options.enabled)
+        return null;
+    if (!isMaintenanceDue(state.lastRunAtMs, options.nowMs, options.minIntervalMs))
+        return null;
+    state.lastRunAtMs = options.nowMs;
+    try {
+        return runMemoryMaintenance(vault, evidenceStore, { nowMs: options.nowMs });
+    }
+    catch {
+        return null;
+    }
+}
 export function handleRunMaintenance(ctx, deps) {
     void ctx;
     const vault = resolveVault(deps);

package/node_modules/@oscharko-dev/keiko-server/dist/memory-retrieval-signals.d.ts

@@ -0,0 +1,12 @@
+import type { MemoryId, MemoryScope } from "@oscharko-dev/keiko-contracts/memory";
+import { type RankingFusionMode } from "@oscharko-dev/keiko-memory-retrieval";
+import type { MemoryVaultStore } from "@oscharko-dev/keiko-memory-vault";
+import type { UiHandlerDeps } from "./deps.js";
+export declare function conversationFusionMode(deps: UiHandlerDeps): RankingFusionMode;
+export interface ConversationRetrievalSignals {
+    readonly semanticById?: ReadonlyMap<MemoryId, number> | undefined;
+    readonly strengthById: ReadonlyMap<MemoryId, number>;
+    readonly embeddingById: ReadonlyMap<MemoryId, Float32Array>;
+}
+export declare function buildConversationRetrievalSignals(deps: UiHandlerDeps, vault: MemoryVaultStore, queryText: string | undefined, scopes: readonly MemoryScope[], nowMs: number, safeForSecondaryModel: boolean): Promise<ConversationRetrievalSignals>;
+//# sourceMappingURL=memory-retrieval-signals.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/memory-retrieval-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-retrieval-signals.d.ts","sourceRoot":"","sources":["../src/memory-retrieval-signals.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,QAAQ,EAAgB,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAChG,OAAO,EAKL,KAAK,iBAAiB,EACvB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAE7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAwD/C,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,aAAa,GAAG,iBAAiB,CAE7E;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAClE,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAIrD,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;CAC7D;AAED,wBAAsB,iCAAiC,CACrD,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,KAAK,EAAE,MAAM,EACb,qBAAqB,EAAE,OAAO,GAC7B,OAAO,CAAC,4BAA4B,CAAC,CAkBvC"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-retrieval-signals.js

@@ -0,0 +1,84 @@
+// Shared conversation-retrieval signal builder (#204, O-F4).
+//
+// Both conversation retrieval surfaces — the desktop chat path (chat-handlers) and the BFF
+// /api/memory/context route (memory-conv-handlers) — need the same two model/usage-derived ranking
+// signals on top of the pure lexical ranker:
+//   - semanticById: per-memory cosine of the query embedding to each candidate's stored vector
+//     (embedding-based recall), gated by the secondary-model egress check.
+//   - strengthById: per-memory reinforcement strength from the vault's access counters (O-P1).
+// Previously only the chat path built them; the BFF route silently ran lexical-only. Centralising
+// them here keeps the two surfaces from drifting (the same class of duplication C3 guards for
+// suppression) and gives any future consumer of the route the stronger embedding signal by default.
+//
+// Pure of policy: the caller decides whether the query is egress-safe and passes that in. Graceful:
+// no embedding model => semanticById undefined (byte-identical lexical fallback); empty access
+// history => strengthById empty (the ranker zeroes its weight).
+import { buildStrengthById, DEFAULT_LIST_BY_SCOPE_MAX_RESULTS, DEFAULT_STALE_CONFIDENCE_THRESHOLD, isMemorySuppressed, } from "@oscharko-dev/keiko-memory-retrieval";
+import { cosineSimilarity, embedMemoryText } from "./memory-embedding.js";
+// A candidate is worth scoring iff the ranker could surface it. A superset of the ranked set is
+// harmless: ids the ranker filters out simply never read their semantic score.
+function isSemanticRetrievalCandidate(record, nowMs) {
+    if (record.status === "superseded")
+        return false;
+    return !isMemorySuppressed(record, nowMs, DEFAULT_STALE_CONFIDENCE_THRESHOLD).suppressed;
+}
+function gatherCandidateIds(vault, scopes, nowMs) {
+    const ids = [];
+    const seen = new Set();
+    for (const scope of scopes) {
+        for (const record of vault.listMemoriesByScope(scope, {
+            includeExpired: true,
+            limit: DEFAULT_LIST_BY_SCOPE_MAX_RESULTS,
+        })) {
+            if (!isSemanticRetrievalCandidate(record, nowMs))
+                continue;
+            if (seen.has(record.id))
+                continue;
+            seen.add(record.id);
+            ids.push(record.id);
+        }
+    }
+    return ids;
+}
+// Per-memory semantic score map for the candidate set, or undefined when no embedding model is
+// configured (query embedding null) — that undefined drives the byte-identical lexical fallback in
+// the ranker. A candidate whose stored vector is missing is omitted (semantic subscore 0 for it).
+// Query-cosine scores for the candidate set, computed from the already-fetched embeddings. Gated by
+// the egress check (it embeds the query). Returns undefined when no model / no query embedding.
+async function semanticScoresFrom(deps, queryText, candidateIds, embeddings) {
+    const queryEmbedding = await embedMemoryText(deps, queryText);
+    if (queryEmbedding === null)
+        return undefined;
+    const scores = new Map();
+    for (const id of candidateIds) {
+        const stored = embeddings.get(id);
+        if (stored === undefined)
+            continue;
+        scores.set(id, cosineSimilarity(queryEmbedding.vector, stored.vector));
+    }
+    return scores;
+}
+// Signal-fusion mode for the conversation retrieval surfaces (#204, O-F2). Opt-in via env to keep
+// the release on the byte-identical weighted-sum default; set KEIKO_MEMORY_FUSION=rrf to enable
+// rank-based Reciprocal Rank Fusion across both the chat and BFF paths.
+export function conversationFusionMode(deps) {
+    return deps.env.KEIKO_MEMORY_FUSION === "rrf" ? "rrf" : "weighted-sum";
+}
+export async function buildConversationRetrievalSignals(deps, vault, queryText, scopes, nowMs, safeForSecondaryModel) {
+    const strengthById = buildStrengthById(vault.getAccessStats(), nowMs);
+    const candidateIds = gatherCandidateIds(vault, scopes, nowMs);
+    const embeddings = candidateIds.length > 0
+        ? vault.getEmbeddings(candidateIds)
+        : new Map();
+    const embeddingById = new Map();
+    for (const [id, row] of embeddings)
+        embeddingById.set(id, row.vector);
+    const semanticById = safeForSecondaryModel && queryText !== undefined && queryText.length > 0 && embeddings.size > 0
+        ? await semanticScoresFrom(deps, queryText, candidateIds, embeddings)
+        : undefined;
+    return {
+        strengthById,
+        embeddingById,
+        ...(semanticById !== undefined ? { semanticById } : {}),
+    };
+}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-salience.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-salience.d.ts","sourceRoot":"","sources":["../src/memory-salience.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AAU3F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,kCAAkC,CAAC;AAqH1C,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;CAC5D;AAID,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,gCAAgC,EACzC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,SAAS,4BAA4B,EAAE,CAAC,CA2ClD"}
+{"version":3,"file":"memory-salience.d.ts","sourceRoot":"","sources":["../src/memory-salience.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AAU3F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,kCAAkC,CAAC;AA0H1C,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;CAC5D;AAID,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,gCAAgC,EACzC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,SAAS,4BAA4B,EAAE,CAAC,CA2ClD"}

package/node_modules/@oscharko-dev/keiko-server/dist/memory-salience.js

@@ -13,7 +13,7 @@ import { extractSalientMemories, memoryTextEgressRejectionReason, } from "@oscha
 import { currentRedactionSecrets } from "./deps.js";
 import { conversationMemoryScopes, } from "./memory-conversation-context.js";
 import { buildMemoryRecordFromProposal } from "./memory-record-builders.js";
-import { embedAndStoreMemory } from "./memory-embedding.js";
+import { insertSalienceMemoryWithNoveltyGate } from "./memory-embedding.js";
 import { isPersistableMemoryCandidate, memoryCapturePolicyForDeps, SENSITIVE_MEMORY_REJECTION_REASON, } from "./memory-capture-policy.js";
 // Mirror of chat-handlers' private scopeLabel (decision 3 — mirrored rather than exported to keep
 // the modules decoupled). Pure and trivial.
@@ -78,9 +78,10 @@ function redactedErrorMessage(error, deps) {
     return redact(message, currentRedactionSecrets(deps));
 }
 // Persists one salience candidate and returns its wire action, or null when the outcome is not a
-// candidate or no record could be built. Best-effort embed-on-capture (#204): the inserted memory
-// is embedded and the vector stored when an embedding model is configured; failure is swallowed by
-// embedAndStoreMemory so capture is never affected.
+// candidate, no record could be built, or the candidate was merged into an existing semantic
+// near-duplicate (#204, O-F1) instead of stored. Embed-on-capture happens INSIDE the novelty gate:
+// the body is embedded once, used to detect a near-duplicate, and stored only when the record is
+// actually inserted. Graceful when no embedding model is configured (plain insert, no dedup).
 async function persistCandidate(deps, outcome, vault) {
     if (outcome.kind !== "candidate") {
         return null;
@@ -93,8 +94,12 @@ async function persistCandidate(deps, outcome, vault) {
     if (record === null) {
         return null;
     }
-    const inserted = vault.insertMemory(record);
-    await embedAndStoreMemory(deps, vault, inserted.id, inserted.body);
+    const { inserted } = await insertSalienceMemoryWithNoveltyGate(deps, vault, record);
+    if (inserted === null) {
+        // Near-duplicate of an existing in-scope memory: the canonical was reinforced, nothing new to
+        // surface. Over-capture is bounded at the encode boundary rather than deferred to a decay pass.
+        return null;
+    }
     return {
         kind: "candidate",
         proposalId: String(inserted.id),

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/figma/figmaConnector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"figmaConnector.d.ts","sourceRoot":"","sources":["../../../src/qualityIntelligence/figma/figmaConnector.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE7F,OAAO,EAIL,KAAK,kBAAkB,EAGvB,KAAK,sBAAsB,EAC5B,MAAM,4BAA4B,CAAC;AAOpC,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAIvC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAE7B,QAAQ,CAAC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAExC,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CACxC;AAED,MAAM,WAAW,cAAc;IAC7B,kGAAkG;IAClG,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACvF;;;;OAIG;IACH,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC5F;AA8ND,eAAO,MAAM,oBAAoB,GAAI,MAAM,kBAAkB,KAAG,cAiB/D,CAAC"}
+{"version":3,"file":"figmaConnector.d.ts","sourceRoot":"","sources":["../../../src/qualityIntelligence/figma/figmaConnector.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE7F,OAAO,EAIL,KAAK,kBAAkB,EAGvB,KAAK,sBAAsB,EAC5B,MAAM,4BAA4B,CAAC;AAYpC,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAIvC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAE7B,QAAQ,CAAC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAExC,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CACxC;AAED,MAAM,WAAW,cAAc;IAC7B,kGAAkG;IAClG,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACvF;;;;OAIG;IACH,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC5F;AAgOD,eAAO,MAAM,oBAAoB,GAAI,MAAM,kBAAkB,KAAG,cAiB/D,CAAC"}

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/figma/figmaConnector.js

@@ -18,9 +18,14 @@ import { resolveReadiness } from "./figmaReadiness.js";
 import { classifyTokenFailure, resolveFigmaToken } from "./figmaTokenSource.js";
 import { DEFAULT_SCOPED_PAGINATION_LIMITS, paginateScopedDocument, resolveScopedPaginationLimits, } from "./figmaScopedPagination.js";
 const FIGMA_API_ORIGIN = "https://api.figma.com";
-const DEFAULT_DEPTH = 4;
+const DEFAULT_DEPTH = 2;
 const DEFAULT_MAX_NODE_COUNT = 5000;
 const EPOCH = "1970-01-01T00:00:00.000Z";
+const DEEP_FETCH_FAIL_SOFT_RETRY_POLICY = {
+    maxRetries: 0,
+    baseDelayMs: 500,
+    maxDelayMs: 500,
+};
 const resolveToken = (deps) => resolveFigmaToken({
     vaultToken: deps.vaultToken,
     configToken: deps.config?.accessToken,
@@ -96,9 +101,9 @@ const DEEP_FETCH_ABORT_CODES = new Set([
 // One scoped `nodes?ids=&depth=` fetch (with 429 backoff), returning the raw document. No oversize
 // guard here — the shallow path applies it; the deep path is bounded by the pagination budgets. The
 // token flows into the header only.
-const fetchDocumentAt = async (rt, token, fileKey, nodeId, fetchDepth, version) => {
+const fetchDocumentAt = async (rt, token, fileKey, nodeId, fetchDepth, version, retryPolicy = rt.retryPolicy) => {
     const requestUrl = buildScopedUrl(fileKey, nodeId, fetchDepth, version);
-    const response = await fetchWithBackoff(() => rt.deps.http({ url: requestUrl, headers: { "X-Figma-Token": token } }), rt.retryPolicy, rt.sleep);
+    const response = await fetchWithBackoff(() => rt.deps.http({ url: requestUrl, headers: { "X-Figma-Token": token } }), retryPolicy, rt.sleep);
     if (response.status < 200 || response.status >= 300) {
         throw statusToError(response.status, response.json);
     }
@@ -134,7 +139,7 @@ const doFetchScopedNodes = async (rt, url, options) => {
 const makeDeepFetcher = (rt, token, target, version) => {
     return async (nodeId) => {
         try {
-            return await fetchDocumentAt(rt, token, target.fileKey, nodeId, rt.paginationLimits.pageDepth, version);
+            return await fetchDocumentAt(rt, token, target.fileKey, nodeId, rt.paginationLimits.pageDepth, version, DEEP_FETCH_FAIL_SOFT_RETRY_POLICY);
         }
         catch (err) {
             if (err instanceof FigmaConnectorError && DEEP_FETCH_ABORT_CODES.has(err.code))

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/figma/figmaScopedPagination.d.ts

@@ -37,11 +37,12 @@ export interface ScopedPaginationLimits {
 }
 /**
  * Defaults balanced for Figma's cost-based rate limit on real, latency-bound boards (NOT tuned to any
- * sample board's content). `pageDepth=8` keeps each request cheap enough to avoid provoking sustained
- * 429s; a small shared pool of 3 in-flight fetches parallelises across screens without bursting the
- * limit; the per-screen budgets expand the densest branches further. On a normal board (screens
- * shallower than `pageDepth`) a single per-screen fetch captures everything and no round runs. The
- * 429 backoff (#759) absorbs occasional rate-limit responses; all of these are deployment-overridable.
+ * sample board's content). `pageDepth=8` captures typical screen bodies in one bounded request, while
+ * a small shared pool of 2 in-flight fetches avoids bursty high-cost 429s. The per-screen and
+ * per-board caps deliberately keep the worst-case live build below 100 deep scoped fetches by
+ * default, so a pasted whole-canvas Release section remains reviewable in the browser instead of
+ * turning into a minutes-long request storm. Operators can raise these budgets per deployment through
+ * KEIKO_FIGMA_* env vars when their Figma plan and proxy allow it.
  */
 export declare const DEFAULT_SCOPED_PAGINATION_LIMITS: ScopedPaginationLimits;
 /** Hard safety ceilings: operators may tune pagination, but never past these finite bounds. */

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/figma/figmaScopedPagination.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"figmaScopedPagination.d.ts","sourceRoot":"","sources":["../../../src/qualityIntelligence/figma/figmaScopedPagination.ts"],"names":[],"mappings":"AAyBA,qGAAqG;AACrG,MAAM,WAAW,YAAY;IAC3B,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;mFACmF;AACnF,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;AAEtF;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC;;mGAE+F;IAC/F,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,0FAA0F;IAC1F,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,wFAAwF;IACxF,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,+FAA+F;IAC/F,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gCAAgC,EAAE,sBAM9C,CAAC;AAEF,+FAA+F;AAC/F,eAAO,MAAM,gCAAgC,EAAE,sBAM9C,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,UAAU,OAAO,CAAC,sBAAsB,CAAC,KACxC,sBAgBF,CAAC;AAEF,wGAAwG;AACxG,MAAM,WAAW,kBAAkB;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,0EAA0E;IAC1E,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,2FAA2F;IAC3F,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uFAAuF;IACvF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,4FAA4F;IAC5F,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;CACvC;AA0CD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,YAAY,KAAG,SAAS,YAAY,EAY7E,CAAC;AA4KF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GACjC,aAAa,YAAY,EACzB,WAAW,iBAAiB,EAC5B,SAAQ,sBAAyD,KAChE,OAAO,CAAC,eAAe,CAsCzB,CAAC"}
+{"version":3,"file":"figmaScopedPagination.d.ts","sourceRoot":"","sources":["../../../src/qualityIntelligence/figma/figmaScopedPagination.ts"],"names":[],"mappings":"AAyBA,qGAAqG;AACrG,MAAM,WAAW,YAAY;IAC3B,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;mFACmF;AACnF,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;AAEtF;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC;;mGAE+F;IAC/F,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,0FAA0F;IAC1F,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,wFAAwF;IACxF,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,+FAA+F;IAC/F,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gCAAgC,EAAE,sBAM9C,CAAC;AAEF,+FAA+F;AAC/F,eAAO,MAAM,gCAAgC,EAAE,sBAM9C,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,UAAU,OAAO,CAAC,sBAAsB,CAAC,KACxC,sBAgBF,CAAC;AAEF,wGAAwG;AACxG,MAAM,WAAW,kBAAkB;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,0EAA0E;IAC1E,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,2FAA2F;IAC3F,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uFAAuF;IACvF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,4FAA4F;IAC5F,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;CACvC;AA0CD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,YAAY,KAAG,SAAS,YAAY,EAY7E,CAAC;AA4KF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GACjC,aAAa,YAAY,EACzB,WAAW,iBAAiB,EAC5B,SAAQ,sBAAyD,KAChE,OAAO,CAAC,eAAe,CAsCzB,CAAC"}

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/figma/figmaScopedPagination.js

@@ -24,18 +24,19 @@
 // assembled tree (and a budget cut-off truncates the same deterministic tail every run).
 /**
  * Defaults balanced for Figma's cost-based rate limit on real, latency-bound boards (NOT tuned to any
- * sample board's content). `pageDepth=8` keeps each request cheap enough to avoid provoking sustained
- * 429s; a small shared pool of 3 in-flight fetches parallelises across screens without bursting the
- * limit; the per-screen budgets expand the densest branches further. On a normal board (screens
- * shallower than `pageDepth`) a single per-screen fetch captures everything and no round runs. The
- * 429 backoff (#759) absorbs occasional rate-limit responses; all of these are deployment-overridable.
+ * sample board's content). `pageDepth=8` captures typical screen bodies in one bounded request, while
+ * a small shared pool of 2 in-flight fetches avoids bursty high-cost 429s. The per-screen and
+ * per-board caps deliberately keep the worst-case live build below 100 deep scoped fetches by
+ * default, so a pasted whole-canvas Release section remains reviewable in the browser instead of
+ * turning into a minutes-long request storm. Operators can raise these budgets per deployment through
+ * KEIKO_FIGMA_* env vars when their Figma plan and proxy allow it.
  */
 export const DEFAULT_SCOPED_PAGINATION_LIMITS = {
     pageDepth: 8,
-    maxNodesPerScreen: 10_000,
-    maxFetchesPerScreen: 32,
-    maxScreensDeep: 80,
-    fetchConcurrency: 3,
+    maxNodesPerScreen: 8_000,
+    maxFetchesPerScreen: 6,
+    maxScreensDeep: 16,
+    fetchConcurrency: 2,
 };
 /** Hard safety ceilings: operators may tune pagination, but never past these finite bounds. */
 export const SCOPED_PAGINATION_LIMIT_CEILINGS = {

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/figma/figmaSnapshotBuilder.d.ts

@@ -24,7 +24,8 @@ export interface BuildFigmaSnapshotInput {
 }
 /**
  * Render the screens and assemble the immutable Figma Snapshot. Render failures degrade to a
- * `skippedScreens` entry (partial render); a non-2xx `/v1/images` call is a hard coded error.
+ * `skippedScreens` entry plus structural-only IR (partial render); a non-2xx `/v1/images` call is
+ * a hard coded error.
  */
 export declare const buildFigmaSnapshot: (input: BuildFigmaSnapshotInput) => Promise<FigmaSnapshot>;
 //# sourceMappingURL=figmaSnapshotBuilder.d.ts.map

package/node_modules/@oscharko-dev/keiko-server/dist/qualityIntelligence/figma/figmaSnapshotBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"figmaSnapshotBuilder.d.ts","sourceRoot":"","sources":["../../../src/qualityIntelligence/figma/figmaSnapshotBuilder.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AAMzB,OAAO,KAAK,EAGV,aAAa,EAEd,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AAiBzF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,wBAAwB,CAAC,cAAc,CAAC;IACrD,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,qEAAqE;IACrE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,+FAA+F;IAC/F,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,wFAAwF;IACxF,QAAQ,CAAC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IACxC,qFAAqF;IACrF,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;CAClC;AAwPD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,uBAAuB,KAC7B,OAAO,CAAC,aAAa,CA2CvB,CAAC"}
+{"version":3,"file":"figmaSnapshotBuilder.d.ts","sourceRoot":"","sources":["../../../src/qualityIntelligence/figma/figmaSnapshotBuilder.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AAMzB,OAAO,KAAK,EAGV,aAAa,EAGd,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AAiBzF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,wBAAwB,CAAC,cAAc,CAAC;IACrD,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,qEAAqE;IACrE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,+FAA+F;IAC/F,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,wFAAwF;IACxF,QAAQ,CAAC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IACxC,qFAAqF;IACrF,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;CAClC;AAuSD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,uBAAuB,KAC7B,OAAO,CAAC,aAAa,CAyCvB,CAAC"}