@psiclawops/hypermem 0.9.1 → 0.9.3

package/dist/content-type-classifier.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Content Type Classifier
+ *
+ * Classifies message content by signal type: decision, spec, preference,
+ * skill, attribute, discussion, ack, or noise. Used by:
+ *   - Keystone history slot (P2.1) for decisional weight scoring
+ *   - Background indexer for extraction priority
+ *   - Compaction for retention decisions
+ *
+ * Ported from ClawText content-type-classifier.ts — adapted for
+ * hypermem's NeutralMessage interface.
+ *
+ * No LLM dependency. Pure pattern matching + heuristics.
+ */
+export type ContentType = 'decision' | 'spec' | 'preference' | 'skill' | 'attribute' | 'discussion' | 'ack' | 'noise';
+export interface ContentTypeResult {
+    type: ContentType;
+    confidence: number;
+    /** Approximate half-life in days. Infinity = never decays. 0 = discard immediately. */
+    halfLifeDays: number;
+}
+/** Signal value weight for context assembly prioritization (0–1). */
+export declare const SIGNAL_WEIGHT: Record<ContentType, number>;
+/**
+ * Classify a message's content by signal type.
+ *
+ * @param content - Raw text content of the message
+ * @returns Classification with type, confidence, and decay half-life
+ */
+export declare function classifyContentType(content: string): ContentTypeResult;
+/**
+ * Convenience: classify and return the signal weight (0–1).
+ * Higher = more valuable for context retention.
+ */
+export declare function signalWeight(content: string): number;
+/**
+ * Convenience: is this message worth keeping in context?
+ * Returns false for ack and noise.
+ */
+export declare function isSignalBearing(content: string): boolean;
+//# sourceMappingURL=content-type-classifier.d.ts.map

package/dist/content-type-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-type-classifier.d.ts","sourceRoot":"","sources":["../src/content-type-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,MAAM,MAAM,WAAW,GACnB,UAAU,GACV,MAAM,GACN,YAAY,GACZ,OAAO,GACP,WAAW,GACX,YAAY,GACZ,KAAK,GACL,OAAO,CAAC;AAEZ,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,WAAW,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,uFAAuF;IACvF,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,qEAAqE;AACrE,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CASrD,CAAC;AAwGF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAmDtE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGpD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGxD"}

package/dist/content-type-classifier.js

@@ -0,0 +1,181 @@
+/**
+ * Content Type Classifier
+ *
+ * Classifies message content by signal type: decision, spec, preference,
+ * skill, attribute, discussion, ack, or noise. Used by:
+ *   - Keystone history slot (P2.1) for decisional weight scoring
+ *   - Background indexer for extraction priority
+ *   - Compaction for retention decisions
+ *
+ * Ported from ClawText content-type-classifier.ts — adapted for
+ * hypermem's NeutralMessage interface.
+ *
+ * No LLM dependency. Pure pattern matching + heuristics.
+ */
+/** Signal value weight for context assembly prioritization (0–1). */
+export const SIGNAL_WEIGHT = {
+    decision: 1.0,
+    spec: 0.85,
+    preference: 0.8,
+    skill: 0.6,
+    attribute: 0.5,
+    discussion: 0.4,
+    ack: 0.0,
+    noise: 0.0,
+};
+// ─── Patterns ───────────────────────────────────────────────────
+const DECISION_PATTERNS = [
+    /\bdecided\b/i,
+    /\bthe approach is\b/i,
+    /\bwe(?:'|')ll go with\b/i,
+    /\bthe plan is\b/i,
+    /\bapproved\b/i,
+    /\bconfirmed\b/i,
+    /\bshipped\b/i,
+    /\bmerged\b/i,
+    /\bdeployed\b/i,
+    /\b(?:decision|verdict|ruling|conclusion)\s*:/i,
+    /🟢\s*GREEN/,
+    /🔴\s*RED/,
+    /🟡\s*YELLOW/,
+];
+const SPEC_PATTERNS = [
+    /```[\s\S]*?```/m,
+    /\binterface\s+[A-Za-z0-9_]+/,
+    /\btype\s+[A-Za-z0-9_]+\s*=/,
+    /\barchitecture\b/i,
+    /\bapi\b/i,
+    /\bcontract\b/i,
+    /\bschema\b/i,
+    /\bmigration\b/i,
+    /\bspec\b/i,
+];
+const PREFERENCE_PATTERNS = [
+    /\b(?:i|we)\s+(?:prefer|like|love|favor)\b/i,
+    /\bmy\s+preferred\b/i,
+    /\bpreference\b/i,
+    /\bi(?:'|')d\s+rather\b/i,
+    /\bdefault\s+to\b/i,
+    /\b(?:always|usually)\s+use\b/i,
+];
+const SKILL_PATTERNS = [
+    /\b(?:i|we)\s+(?:know|understand|can|able to)\b/i,
+    /\b(?:experienced|proficient|expert)\s+with\b/i,
+    /\b(?:skill|strength|competenc(?:y|ies))\b/i,
+    /\b(?:familiar|comfortable)\s+with\b/i,
+];
+const ATTRIBUTE_PATTERNS = [
+    /\b(?:i|we)\s+(?:am|are)\b/i,
+    /\bmy\s+(?:role|timezone|location|name|pronouns|schedule|availability)\b/i,
+    /\b(?:timezone|pronouns|role|availability|schedule)\s*:/i,
+    /\b(?:working\s+hours|hard\s+stop|deadline)\b/i,
+];
+const NOISE_PATTERNS = [
+    /\bheartbeat\b/i,
+    /\braw log\b/i,
+    /^\[[A-Z_]+\]/m,
+    /\b(system|daemon|telemetry)\s+message\b/i,
+    /\btraceback\b/i,
+    /\bstdout\b/i,
+    /\bstderr\b/i,
+    /^NO_REPLY$/,
+    /^HEARTBEAT_OK$/,
+];
+const ACK_PHRASES = new Set([
+    'ok',
+    'okay',
+    'yes',
+    'sounds good',
+    'lets do it',
+    "let's do it",
+    'perfect',
+    'nice',
+    'got it',
+    'acknowledged',
+    'roger',
+    'done',
+    'thanks',
+    'thank you',
+    'ty',
+    'lgtm',
+    '👍',
+]);
+const HALF_LIFE = {
+    decision: Number.POSITIVE_INFINITY,
+    spec: 180,
+    preference: 180,
+    skill: 120,
+    attribute: 30,
+    discussion: 60,
+    ack: 0,
+    noise: 0,
+};
+// ─── Classifier ─────────────────────────────────────────────────
+function normalized(content) {
+    return content.trim().toLowerCase().replace(/[.!?]+$/g, '');
+}
+/**
+ * Classify a message's content by signal type.
+ *
+ * @param content - Raw text content of the message
+ * @returns Classification with type, confidence, and decay half-life
+ */
+export function classifyContentType(content) {
+    const raw = String(content ?? '');
+    const body = raw.trim();
+    const lc = normalized(body);
+    if (!body) {
+        return { type: 'noise', confidence: 0.95, halfLifeDays: HALF_LIFE.noise };
+    }
+    // Noise first — fast path for system/control messages
+    if (NOISE_PATTERNS.some((rx) => rx.test(body))) {
+        return { type: 'noise', confidence: 0.85, halfLifeDays: HALF_LIFE.noise };
+    }
+    // Short acks — "ok", "sounds good", etc.
+    if (body.length < 40 && ACK_PHRASES.has(lc)) {
+        return { type: 'ack', confidence: 0.95, halfLifeDays: HALF_LIFE.ack };
+    }
+    // Decisions — highest value signal
+    if (DECISION_PATTERNS.some((rx) => rx.test(body))) {
+        return { type: 'decision', confidence: 0.9, halfLifeDays: HALF_LIFE.decision };
+    }
+    // Specs — code blocks, type definitions, architecture
+    if (SPEC_PATTERNS.some((rx) => rx.test(body))) {
+        return { type: 'spec', confidence: 0.82, halfLifeDays: HALF_LIFE.spec };
+    }
+    // Preferences — user likes, defaults
+    if (PREFERENCE_PATTERNS.some((rx) => rx.test(body))) {
+        return { type: 'preference', confidence: 0.8, halfLifeDays: HALF_LIFE.preference };
+    }
+    // Skills — capabilities, knowledge
+    if (SKILL_PATTERNS.some((rx) => rx.test(body))) {
+        return { type: 'skill', confidence: 0.78, halfLifeDays: HALF_LIFE.skill };
+    }
+    // Attributes — identity, schedule, role
+    if (ATTRIBUTE_PATTERNS.some((rx) => rx.test(body))) {
+        return { type: 'attribute', confidence: 0.72, halfLifeDays: HALF_LIFE.attribute };
+    }
+    // Questions and exploratory discussion
+    if (/\?$/.test(body) || /\b(why|how|maybe|could|should|explore|question)\b/i.test(body)) {
+        return { type: 'discussion', confidence: 0.75, halfLifeDays: HALF_LIFE.discussion };
+    }
+    // Default: generic discussion
+    return { type: 'discussion', confidence: 0.6, halfLifeDays: HALF_LIFE.discussion };
+}
+/**
+ * Convenience: classify and return the signal weight (0–1).
+ * Higher = more valuable for context retention.
+ */
+export function signalWeight(content) {
+    const { type } = classifyContentType(content);
+    return SIGNAL_WEIGHT[type];
+}
+/**
+ * Convenience: is this message worth keeping in context?
+ * Returns false for ack and noise.
+ */
+export function isSignalBearing(content) {
+    const { type } = classifyContentType(content);
+    return type !== 'ack' && type !== 'noise';
+}
+//# sourceMappingURL=content-type-classifier.js.map

package/dist/context-backfill.d.ts

@@ -0,0 +1,46 @@
+/**
+ * hypermem Context Backfill
+ *
+ * One-time migration that creates context rows for existing conversations
+ * that don't yet have an active context. Designed to be idempotent — running
+ * it multiple times produces the same result without modifying existing data.
+ *
+ * Also provides parent chain backfill (Phase 2): reconstructs parent_id/depth
+ * for legacy flat conversations that were created before the Turn DAG model.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+/**
+ * Backfill active contexts for all existing conversations.
+ *
+ * For each conversation without an active context:
+ *   1. Creates an active context via getOrCreateActiveContext
+ *   2. If the conversation has messages, advances the head pointer
+ *      to the highest message ID
+ *
+ * @returns counts of created and skipped conversations
+ */
+export declare function backfillContexts(db: DatabaseSync): {
+    created: number;
+    skipped: number;
+};
+/**
+ * Backfill parent_id and depth for existing messages that lack them.
+ *
+ * Reconstructs a linear chain per conversation ordered by message_index:
+ *   - first message: parent_id = NULL, depth = 0
+ *   - each subsequent: parent_id = previous.id, depth = previous.depth + 1
+ *
+ * Idempotent: only touches messages where parent_id IS NULL AND depth = 0
+ * AND there is more than one message or the message is not the first.
+ * In practice, we simply skip messages that already have parent_id set.
+ *
+ * Also stamps context_id on messages that lack it, using the active context
+ * for their conversation.
+ *
+ * @returns counts of messages updated and conversations processed
+ */
+export declare function backfillParentChains(db: DatabaseSync): {
+    conversationsProcessed: number;
+    messagesUpdated: number;
+};
+//# sourceMappingURL=context-backfill.d.ts.map

package/dist/context-backfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-backfill.d.ts","sourceRoot":"","sources":["../src/context-backfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,YAAY,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAwCvF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,YAAY,GACf;IAAE,sBAAsB,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,CA+D7D"}

package/dist/context-backfill.js

@@ -0,0 +1,113 @@
+/**
+ * hypermem Context Backfill
+ *
+ * One-time migration that creates context rows for existing conversations
+ * that don't yet have an active context. Designed to be idempotent — running
+ * it multiple times produces the same result without modifying existing data.
+ *
+ * Also provides parent chain backfill (Phase 2): reconstructs parent_id/depth
+ * for legacy flat conversations that were created before the Turn DAG model.
+ */
+import { getOrCreateActiveContext, updateContextHead } from './context-store.js';
+/**
+ * Backfill active contexts for all existing conversations.
+ *
+ * For each conversation without an active context:
+ *   1. Creates an active context via getOrCreateActiveContext
+ *   2. If the conversation has messages, advances the head pointer
+ *      to the highest message ID
+ *
+ * @returns counts of created and skipped conversations
+ */
+export function backfillContexts(db) {
+    let created = 0;
+    let skipped = 0;
+    const conversations = db
+        .prepare('SELECT id, agent_id, session_key FROM conversations')
+        .all();
+    for (const conv of conversations) {
+        // Check if an active context already exists for this conversation
+        const existing = db
+            .prepare("SELECT id FROM contexts WHERE conversation_id = ? AND status = 'active'")
+            .get(conv.id);
+        if (existing) {
+            skipped++;
+            continue;
+        }
+        // Find the max message ID for this conversation (may be null if no messages)
+        const maxRow = db
+            .prepare('SELECT MAX(id) as max_id FROM messages WHERE conversation_id = ?')
+            .get(conv.id);
+        const maxId = maxRow?.max_id ?? null;
+        // Create the active context
+        const context = getOrCreateActiveContext(db, conv.agent_id, conv.session_key, conv.id);
+        // If conversation has messages, advance head to the latest
+        if (maxId !== null) {
+            updateContextHead(db, context.id, maxId);
+        }
+        created++;
+    }
+    return { created, skipped };
+}
+/**
+ * Backfill parent_id and depth for existing messages that lack them.
+ *
+ * Reconstructs a linear chain per conversation ordered by message_index:
+ *   - first message: parent_id = NULL, depth = 0
+ *   - each subsequent: parent_id = previous.id, depth = previous.depth + 1
+ *
+ * Idempotent: only touches messages where parent_id IS NULL AND depth = 0
+ * AND there is more than one message or the message is not the first.
+ * In practice, we simply skip messages that already have parent_id set.
+ *
+ * Also stamps context_id on messages that lack it, using the active context
+ * for their conversation.
+ *
+ * @returns counts of messages updated and conversations processed
+ */
+export function backfillParentChains(db) {
+    let conversationsProcessed = 0;
+    let messagesUpdated = 0;
+    // Get all conversations that have at least one non-first message without parent_id.
+    // This is the idempotency guard: after backfill, all messages at index > 0
+    // have parent_id set. The first message (index 0) legitimately has parent_id = NULL.
+    const conversations = db
+        .prepare(`SELECT DISTINCT conversation_id
+       FROM messages
+       WHERE message_index > 0 AND parent_id IS NULL
+       ORDER BY conversation_id`)
+        .all();
+    const updateStmt = db.prepare('UPDATE messages SET parent_id = ?, depth = ?, context_id = COALESCE(context_id, ?) WHERE id = ?');
+    for (const { conversation_id: convId } of conversations) {
+        // Get active context for this conversation (if any)
+        const ctxRow = db
+            .prepare("SELECT id FROM contexts WHERE conversation_id = ? AND status = 'active' LIMIT 1")
+            .get(convId);
+        const contextId = ctxRow?.id ?? null;
+        // Get all messages for this conversation without parent_id, ordered by message_index
+        const messages = db
+            .prepare('SELECT id, message_index FROM messages WHERE conversation_id = ? AND parent_id IS NULL ORDER BY message_index ASC')
+            .all(convId);
+        if (messages.length === 0)
+            continue;
+        // Also get the last message that already HAS a parent_id (if any),
+        // so we can chain the backfilled messages after it.
+        const lastChainedRow = db
+            .prepare('SELECT id, depth FROM messages WHERE conversation_id = ? AND parent_id IS NOT NULL ORDER BY message_index DESC LIMIT 1')
+            .get(convId);
+        let prevId = lastChainedRow?.id ?? null;
+        let prevDepth = lastChainedRow?.depth ?? -1;
+        // If there's no prior chain AND the first unlinked message is truly
+        // message_index 0, start the chain from scratch
+        for (const msg of messages) {
+            const depth = prevDepth + 1;
+            updateStmt.run(prevId, depth, contextId, msg.id);
+            prevId = msg.id;
+            prevDepth = depth;
+            messagesUpdated++;
+        }
+        conversationsProcessed++;
+    }
+    return { conversationsProcessed, messagesUpdated };
+}
+//# sourceMappingURL=context-backfill.js.map

package/dist/context-store.d.ts

@@ -0,0 +1,131 @@
+/**
+ * hypermem Context Store
+ *
+ * Manages the `contexts` table — a durable record of agent conversation
+ * contexts that tracks which session is active, what the current head
+ * message is, and supports archival and forking.
+ *
+ * Each agent + session pair has at most one active context at a time.
+ * Contexts are the anchor point for the compositor: they track the
+ * head message (most recent message included in composed context) and
+ * link back to the underlying conversation.
+ *
+ * Design principles:
+ *   - All functions take DatabaseSync as first arg (standalone, no classes)
+ *   - Fully idempotent — safe to call on every startup
+ *   - Head pointer is monotone-forward (never moves backward)
+ *   - Archive is idempotent (no-op if already archived)
+ */
+import type { DatabaseSync } from 'node:sqlite';
+export interface Context {
+    id: number;
+    agentId: string;
+    sessionKey: string;
+    conversationId: number;
+    headMessageId: number | null;
+    parentContextId: number | null;
+    status: 'active' | 'archived' | 'forked';
+    createdAt: string;
+    updatedAt: string;
+    metadataJson: string | null;
+}
+/**
+ * Add the contexts table and related indexes to an existing messages.db.
+ * Also ALTERs the messages table to add a context_id foreign key column.
+ * Idempotent — safe to call on every startup.
+ */
+export declare function ensureContextSchema(db: DatabaseSync): void;
+/**
+ * Get the active context for an agent + session pair.
+ * Returns null if no active context exists.
+ */
+export declare function getActiveContext(db: DatabaseSync, agentId: string, sessionKey: string): Context | null;
+/**
+ * Get the active context for an agent + session, creating one if none exists.
+ *
+ * If an active context already exists, returns it unchanged.
+ * Otherwise INSERTs a new context with status='active', head_message_id=NULL,
+ * and the given conversationId.
+ *
+ * Idempotent — safe to call repeatedly.
+ */
+export declare function getOrCreateActiveContext(db: DatabaseSync, agentId: string, sessionKey: string, conversationId: number): Context;
+/**
+ * Update the head message pointer for a context.
+ *
+ * Monotone forward: only updates if messageId > current head_message_id
+ * (or current is NULL). This prevents accidental regression of the head
+ * pointer, matching the compaction-fence monotone progress pattern.
+ */
+export declare function updateContextHead(db: DatabaseSync, contextId: number, messageId: number): void;
+/**
+ * Archive a context, setting its status to 'archived'.
+ * Idempotent — no-op if already archived.
+ */
+export declare function archiveContext(db: DatabaseSync, contextId: number): void;
+/**
+ * Get any context by id, regardless of status.
+ * Returns null if not found.
+ *
+ * @boundary INSPECTION ONLY — not a mining entry point.
+ * @policy See specs/DAG_HELPER_POLICY.md for helper classifications.
+ * Do not use this function to retrieve messages for active composition or
+ * historical mining. Use getArchivedContext + mineArchivedContext for archived
+ * mining, and getActiveContext for composition-path access.
+ */
+export declare function getContextById(db: DatabaseSync, contextId: number): Context | null;
+/**
+ * Get all archived or forked contexts for an agent.
+ * Optionally filter by sessionKey and/or limit.
+ * Returns in reverse-chronological order (most recently updated first).
+ *
+ * @policy See specs/DAG_HELPER_POLICY.md. This is the operator-safe
+ * archived-context enumeration path.
+ */
+export declare function getArchivedContexts(db: DatabaseSync, agentId: string, opts?: {
+    sessionKey?: string;
+    limit?: number;
+}): Context[];
+/**
+ * Get an archived or forked context by id.
+ * Returns null if the context does not exist OR if it is active.
+ *
+ * @policy See specs/DAG_HELPER_POLICY.md. This is the operator-safe
+ * single-context lookup path.
+ */
+export declare function getArchivedContext(db: DatabaseSync, contextId: number): Context | null;
+/**
+ * Walk the parent_context_id chain upward from the given context.
+ * Returns contexts in leaf-to-root order (starting context first).
+ * Includes the starting context itself.
+ * Caps traversal depth at 100 to avoid corrupt loops.
+ *
+ * @boundary STATUS-CROSSING BY DESIGN — this function traverses across
+ * active, archived, and forked contexts without filtering by status.
+ * @policy See specs/DAG_HELPER_POLICY.md for the call-site filtering rule.
+ * If you need only archived/forked contexts in the lineage chain, filter
+ * the returned array at the call site (e.g. `.filter(c => c.status !== 'active')`).
+ */
+export declare function getContextLineage(db: DatabaseSync, contextId: number): Context[];
+/**
+ * Get direct fork children of a context (contexts with parent_context_id = parentContextId).
+ * Returns in ascending creation order.
+ *
+ * @boundary STATUS-CROSSING BY DESIGN — returns children regardless of their status
+ * (may include active, archived, or forked children).
+ * @policy See specs/DAG_HELPER_POLICY.md for the call-site filtering rule.
+ * Filter at the call site if archived-only results are needed.
+ */
+export declare function getForkChildren(db: DatabaseSync, parentContextId: number): Context[];
+/**
+ * Rotate a session's active context: archive the current active context
+ * and create a new one, optionally linking back via parent_context_id.
+ *
+ * Used on session restarts/rotations so the new context starts with a
+ * clean head pointer instead of inheriting the stale tail.
+ *
+ * Returns the newly created active context.
+ * If no active context exists, simply creates one (no archive step).
+ */
+export declare function rotateSessionContext(db: DatabaseSync, agentId: string, sessionKey: string, conversationId: number): Context;
+//# sourceMappingURL=context-store.d.ts.map

package/dist/context-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-store.d.ts","sourceRoot":"","sources":["../src/context-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIhD,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,MAAM,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAyBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAmC1D;AAID;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,OAAO,GAAG,IAAI,CAShB;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GACrB,OAAO,CAwBT;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,IAAI,CAeN;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,GAChB,IAAI,CAMN;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,GAAG,IAAI,CAOhB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE;IACL,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GACA,OAAO,EAAE,CAkBX;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,GAAG,IAAI,CAOhB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,EAAE,CAqBX;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,YAAY,EAChB,eAAe,EAAE,MAAM,GACtB,OAAO,EAAE,CAMX;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GACrB,OAAO,CA2BT"}