monora-ai 2.0.0 → 2.1.3

package/dist/lifecycle.js

@@ -0,0 +1,624 @@
+"use strict";
+/**
+ * AI System Life Cycle Registry for ISO 42001 A.6 compliance.
+ *
+ * This module provides AI System Life Cycle tracking supporting ISO 42001 controls:
+ * - A.6.1.2: Objectives for responsible development
+ * - A.6.1.3: Processes for responsible design
+ * - A.6.2.2: System requirements and specification
+ * - A.6.2.4: Verification and validation
+ * - A.6.2.5: Deployment documentation
+ *
+ * Cross-SDK Parity:
+ *   Both Python and Node.js SDKs provide identical lifecycle APIs:
+ *   - createSystemRecord() / create_system_record()
+ *   - registerSystem() / register_system()
+ *   - addRequirement() / add_requirement()
+ *   - recordVerification() / record_verification()
+ *   - transitionStage() / transition_stage()
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectiveToDict = objectiveToDict;
+exports.documentRefToDict = documentRefToDict;
+exports.requirementToDict = requirementToDict;
+exports.verificationRecordToDict = verificationRecordToDict;
+exports.validationRecordToDict = validationRecordToDict;
+exports.checklistItemToDict = checklistItemToDict;
+exports.deploymentPlanToDict = deploymentPlanToDict;
+exports.stageTransitionToDict = stageTransitionToDict;
+exports.systemRecordToDict = systemRecordToDict;
+exports.createSystemRecord = createSystemRecord;
+exports.registerSystem = registerSystem;
+exports.getSystemRecord = getSystemRecord;
+exports.getAllSystems = getAllSystems;
+exports.clearSystems = clearSystems;
+exports.addObjective = addObjective;
+exports.addDocument = addDocument;
+exports.addRequirement = addRequirement;
+exports.recordVerification = recordVerification;
+exports.recordValidation = recordValidation;
+exports.setDeploymentPlan = setDeploymentPlan;
+exports.approveDeployment = approveDeployment;
+exports.addChecklistItem = addChecklistItem;
+exports.completeChecklistItem = completeChecklistItem;
+exports.validateStageTransition = validateStageTransition;
+exports.transitionStage = transitionStage;
+exports.getRequirementsTraceability = getRequirementsTraceability;
+exports.getLifecycleSummary = getLifecycleSummary;
+exports.getLifecycleReport = getLifecycleReport;
+exports.emitSystemRecord = emitSystemRecord;
+const crypto_1 = require("crypto");
+const logger_1 = require("./logger");
+/**
+ * Generate a deterministic ID from parts.
+ */
+function generateId(prefix, ...parts) {
+    const combined = parts.join(':');
+    const hash = (0, crypto_1.createHash)('sha256').update(combined).digest('hex').slice(0, 12);
+    return `${prefix}_${hash}`;
+}
+/**
+ * Get current UTC timestamp in ISO format.
+ */
+function nowIso() {
+    return new Date().toISOString();
+}
+function objectiveToDict(obj) {
+    return {
+        objective_id: obj.objectiveId,
+        description: obj.description,
+        rationale: obj.rationale,
+        success_criteria: obj.successCriteria,
+        status: obj.status,
+    };
+}
+function documentRefToDict(doc) {
+    return {
+        doc_id: doc.docId,
+        title: doc.title,
+        doc_type: doc.docType,
+        path_or_url: doc.pathOrUrl,
+        version: doc.version,
+        last_updated: doc.lastUpdated,
+    };
+}
+function requirementToDict(req) {
+    return {
+        req_id: req.reqId,
+        type: req.type,
+        description: req.description,
+        acceptance_criteria: req.acceptanceCriteria,
+        verification_method: req.verificationMethod,
+        status: req.status,
+        linked_tests: req.linkedTests,
+    };
+}
+function verificationRecordToDict(rec) {
+    const result = {
+        verification_id: rec.verificationId,
+        requirement_id: rec.requirementId,
+        method: rec.method,
+        result: rec.result,
+        evidence_refs: rec.evidenceRefs,
+        verified_at: rec.verifiedAt,
+        verified_by: rec.verifiedBy,
+    };
+    if (rec.notes) {
+        result.notes = rec.notes;
+    }
+    return result;
+}
+function validationRecordToDict(rec) {
+    return {
+        validation_id: rec.validationId,
+        requirement_id: rec.requirementId,
+        method: rec.method,
+        result: rec.result,
+        findings: rec.findings,
+        validated_at: rec.validatedAt,
+        validated_by: rec.validatedBy,
+    };
+}
+function checklistItemToDict(item) {
+    const result = {
+        item_id: item.itemId,
+        description: item.description,
+        required: item.required,
+        completed: item.completed,
+    };
+    if (item.completedAt)
+        result.completed_at = item.completedAt;
+    if (item.completedBy)
+        result.completed_by = item.completedBy;
+    if (item.evidenceRef)
+        result.evidence_ref = item.evidenceRef;
+    return result;
+}
+function deploymentPlanToDict(plan) {
+    const result = {
+        plan_id: plan.planId,
+        target_environment: plan.targetEnvironment,
+        rollback_procedure: plan.rollbackProcedure,
+        monitoring_setup: plan.monitoringSetup,
+        approval_status: plan.approvalStatus,
+    };
+    if (plan.deploymentDate)
+        result.deployment_date = plan.deploymentDate;
+    if (plan.approvedBy)
+        result.approved_by = plan.approvedBy;
+    if (plan.approvedAt)
+        result.approved_at = plan.approvedAt;
+    return result;
+}
+function stageTransitionToDict(trans) {
+    return {
+        from_stage: trans.fromStage,
+        to_stage: trans.toStage,
+        transitioned_at: trans.transitionedAt,
+        transitioned_by: trans.transitionedBy,
+        rationale: trans.rationale,
+    };
+}
+function systemRecordToDict(system) {
+    const result = {
+        system_id: system.systemId,
+        name: system.name,
+        version: system.version,
+        stage: system.stage,
+        objectives: system.objectives.map(objectiveToDict),
+        design_documents: system.designDocuments.map(documentRefToDict),
+        requirements: system.requirements.map(requirementToDict),
+        verification_results: system.verificationResults.map(verificationRecordToDict),
+        validation_results: system.validationResults.map(validationRecordToDict),
+        deployment_checklist: system.deploymentChecklist.map(checklistItemToDict),
+        created_at: system.createdAt,
+        updated_at: system.updatedAt,
+        stage_history: system.stageHistory.map(stageTransitionToDict),
+    };
+    if (system.deploymentPlan) {
+        result.deployment_plan = deploymentPlanToDict(system.deploymentPlan);
+    }
+    return result;
+}
+// Runtime system registry
+const systems = new Map();
+function createSystemRecord(options) {
+    const record = {
+        systemId: options.systemId,
+        name: options.name,
+        version: options.version || '1.0.0',
+        stage: options.stage || 'design',
+        objectives: [],
+        designDocuments: [],
+        requirements: [],
+        verificationResults: [],
+        validationResults: [],
+        deploymentChecklist: [],
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+        stageHistory: [],
+    };
+    systems.set(options.systemId, record);
+    return record;
+}
+/**
+ * Register an existing system record.
+ */
+function registerSystem(record) {
+    systems.set(record.systemId, record);
+}
+/**
+ * Get a system record by ID.
+ */
+function getSystemRecord(systemId) {
+    return systems.get(systemId);
+}
+/**
+ * Get all registered system records.
+ */
+function getAllSystems() {
+    return Array.from(systems.values());
+}
+/**
+ * Clear all system records from the registry.
+ */
+function clearSystems() {
+    systems.clear();
+}
+function addObjective(options) {
+    const system = systems.get(options.systemId);
+    if (!system) {
+        throw new Error(`System ${options.systemId} not found`);
+    }
+    const objectiveId = generateId('obj', options.systemId, options.description.slice(0, 20));
+    const objective = {
+        objectiveId,
+        description: options.description,
+        rationale: options.rationale,
+        successCriteria: options.successCriteria || [],
+        status: 'defined',
+    };
+    system.objectives.push(objective);
+    system.updatedAt = nowIso();
+    return objective;
+}
+function addDocument(options) {
+    const system = systems.get(options.systemId);
+    if (!system) {
+        throw new Error(`System ${options.systemId} not found`);
+    }
+    const docId = generateId('doc', options.systemId, options.title.slice(0, 20));
+    const doc = {
+        docId,
+        title: options.title,
+        docType: options.docType,
+        pathOrUrl: options.pathOrUrl,
+        version: options.version || '1.0',
+        lastUpdated: nowIso(),
+    };
+    system.designDocuments.push(doc);
+    system.updatedAt = nowIso();
+    return doc;
+}
+function addRequirement(options) {
+    const system = systems.get(options.systemId);
+    if (!system) {
+        throw new Error(`System ${options.systemId} not found`);
+    }
+    const reqId = generateId('req', options.systemId, options.reqType, options.description.slice(0, 20));
+    const req = {
+        reqId,
+        type: options.reqType,
+        description: options.description,
+        acceptanceCriteria: options.acceptanceCriteria || [],
+        verificationMethod: options.verificationMethod || 'unit_test',
+        status: 'defined',
+        linkedTests: [],
+    };
+    system.requirements.push(req);
+    system.updatedAt = nowIso();
+    return req;
+}
+function recordVerification(options) {
+    const system = systems.get(options.systemId);
+    if (!system) {
+        throw new Error(`System ${options.systemId} not found`);
+    }
+    // Update requirement status
+    let reqFound = false;
+    for (const req of system.requirements) {
+        if (req.reqId === options.requirementId) {
+            reqFound = true;
+            if (options.result === 'pass') {
+                req.status = 'verified';
+            }
+            break;
+        }
+    }
+    if (!reqFound) {
+        throw new Error(`Requirement ${options.requirementId} not found in system ${options.systemId}`);
+    }
+    const verificationId = generateId('ver', options.systemId, options.requirementId);
+    const verification = {
+        verificationId,
+        requirementId: options.requirementId,
+        method: options.method,
+        result: options.result,
+        evidenceRefs: options.evidenceRefs || [],
+        verifiedAt: nowIso(),
+        verifiedBy: options.verifiedBy,
+        notes: options.notes,
+    };
+    system.verificationResults.push(verification);
+    system.updatedAt = nowIso();
+    return verification;
+}
+function recordValidation(options) {
+    const system = systems.get(options.systemId);
+    if (!system) {
+        throw new Error(`System ${options.systemId} not found`);
+    }
+    // Update requirement status
+    let reqFound = false;
+    for (const req of system.requirements) {
+        if (req.reqId === options.requirementId) {
+            reqFound = true;
+            if (options.result === 'pass') {
+                req.status = 'validated';
+            }
+            break;
+        }
+    }
+    if (!reqFound) {
+        throw new Error(`Requirement ${options.requirementId} not found in system ${options.systemId}`);
+    }
+    const validationId = generateId('val', options.systemId, options.requirementId);
+    const validation = {
+        validationId,
+        requirementId: options.requirementId,
+        method: options.method,
+        result: options.result,
+        findings: options.findings || [],
+        validatedAt: nowIso(),
+        validatedBy: options.validatedBy,
+    };
+    system.validationResults.push(validation);
+    system.updatedAt = nowIso();
+    return validation;
+}
+function setDeploymentPlan(options) {
+    const system = systems.get(options.systemId);
+    if (!system) {
+        throw new Error(`System ${options.systemId} not found`);
+    }
+    const planId = generateId('plan', options.systemId, options.targetEnvironment);
+    const plan = {
+        planId,
+        targetEnvironment: options.targetEnvironment,
+        deploymentDate: options.deploymentDate,
+        rollbackProcedure: options.rollbackProcedure || '',
+        monitoringSetup: options.monitoringSetup || '',
+        approvalStatus: 'pending',
+    };
+    system.deploymentPlan = plan;
+    system.updatedAt = nowIso();
+    return plan;
+}
+/**
+ * Approve a deployment plan (A.6.2.5).
+ */
+function approveDeployment(systemId, approvedBy) {
+    const system = systems.get(systemId);
+    if (!system) {
+        throw new Error(`System ${systemId} not found`);
+    }
+    if (!system.deploymentPlan) {
+        throw new Error(`System ${systemId} has no deployment plan`);
+    }
+    system.deploymentPlan.approvalStatus = 'approved';
+    system.deploymentPlan.approvedBy = approvedBy;
+    system.deploymentPlan.approvedAt = nowIso();
+    system.updatedAt = nowIso();
+    return system.deploymentPlan;
+}
+function addChecklistItem(options) {
+    const system = systems.get(options.systemId);
+    if (!system) {
+        throw new Error(`System ${options.systemId} not found`);
+    }
+    const itemId = generateId('chk', options.systemId, options.description.slice(0, 20));
+    const item = {
+        itemId,
+        description: options.description,
+        required: options.required !== false,
+        completed: false,
+    };
+    system.deploymentChecklist.push(item);
+    system.updatedAt = nowIso();
+    return item;
+}
+function completeChecklistItem(options) {
+    const system = systems.get(options.systemId);
+    if (!system) {
+        throw new Error(`System ${options.systemId} not found`);
+    }
+    for (const item of system.deploymentChecklist) {
+        if (item.itemId === options.itemId) {
+            item.completed = true;
+            item.completedAt = nowIso();
+            item.completedBy = options.completedBy;
+            item.evidenceRef = options.evidenceRef;
+            system.updatedAt = nowIso();
+            return item;
+        }
+    }
+    throw new Error(`Checklist item ${options.itemId} not found in system ${options.systemId}`);
+}
+/**
+ * Validate prerequisites for a stage transition.
+ */
+function validateStageTransition(system, newStage, config) {
+    const errors = [];
+    const lifecycleConfig = config?.lifecycle;
+    const prerequisites = lifecycleConfig?.stage_prerequisites || {};
+    const stagePrereqs = prerequisites[newStage] || [];
+    for (const prereq of stagePrereqs) {
+        if (prereq === 'requirements_defined') {
+            if (system.requirements.length === 0) {
+                errors.push('No requirements defined');
+            }
+        }
+        else if (prereq === 'verification_complete') {
+            const verifiedReqs = new Set(system.verificationResults.filter(v => v.result === 'pass').map(v => v.requirementId));
+            const unverified = system.requirements.filter(r => !verifiedReqs.has(r.reqId)).map(r => r.reqId);
+            if (unverified.length > 0) {
+                errors.push(`Requirements not verified: ${unverified.join(', ')}`);
+            }
+        }
+        else if (prereq === 'validation_complete') {
+            const validatedReqs = new Set(system.validationResults.filter(v => v.result === 'pass').map(v => v.requirementId));
+            const unvalidated = system.requirements.filter(r => !validatedReqs.has(r.reqId)).map(r => r.reqId);
+            if (unvalidated.length > 0) {
+                errors.push(`Requirements not validated: ${unvalidated.join(', ')}`);
+            }
+        }
+        else if (prereq === 'deployment_approved') {
+            if (!system.deploymentPlan || system.deploymentPlan.approvalStatus !== 'approved') {
+                errors.push('Deployment plan not approved');
+            }
+        }
+        else if (prereq === 'decommission_plan') {
+            const decomDocs = system.designDocuments.filter(d => d.docType === 'decommission_plan');
+            if (decomDocs.length === 0) {
+                errors.push('No decommission plan document');
+            }
+        }
+    }
+    return errors;
+}
+function transitionStage(options) {
+    const system = systems.get(options.systemId);
+    if (!system) {
+        throw new Error(`System ${options.systemId} not found`);
+    }
+    const oldStage = system.stage;
+    // Validate prerequisites unless forced
+    if (!options.force) {
+        const errors = validateStageTransition(system, options.newStage, options.config);
+        if (errors.length > 0) {
+            throw new Error(`Prerequisites not met for ${options.newStage}: ${errors.join('; ')}`);
+        }
+    }
+    // Record the transition
+    const transition = {
+        fromStage: oldStage,
+        toStage: options.newStage,
+        transitionedAt: nowIso(),
+        transitionedBy: options.transitionedBy,
+        rationale: options.rationale,
+    };
+    system.stageHistory.push(transition);
+    system.stage = options.newStage;
+    system.updatedAt = nowIso();
+    // Update deployment plan status if transitioning to production
+    if (options.newStage === 'production' && system.deploymentPlan) {
+        system.deploymentPlan.approvalStatus = 'deployed';
+    }
+    // Emit lifecycle event
+    emitLifecycleEvent(system, 'system_stage_transition', options.config);
+    return system;
+}
+/**
+ * Get requirements traceability matrix for a system.
+ */
+function getRequirementsTraceability(systemId) {
+    const system = systems.get(systemId);
+    if (!system) {
+        return {};
+    }
+    const verifiedReqs = new Map(system.verificationResults.map(v => [v.requirementId, v]));
+    const validatedReqs = new Map(system.validationResults.map(v => [v.requirementId, v]));
+    const matrix = system.requirements.map(req => {
+        const entry = {
+            req_id: req.reqId,
+            type: req.type,
+            description: req.description,
+            status: req.status,
+            verified: verifiedReqs.has(req.reqId),
+            validated: validatedReqs.has(req.reqId),
+        };
+        const verRec = verifiedReqs.get(req.reqId);
+        if (verRec) {
+            entry.verification = {
+                method: verRec.method,
+                result: verRec.result,
+                verified_at: verRec.verifiedAt,
+            };
+        }
+        const valRec = validatedReqs.get(req.reqId);
+        if (valRec) {
+            entry.validation = {
+                method: valRec.method,
+                result: valRec.result,
+                validated_at: valRec.validatedAt,
+            };
+        }
+        return entry;
+    });
+    return {
+        system_id: systemId,
+        system_name: system.name,
+        stage: system.stage,
+        requirements: matrix,
+        total_requirements: system.requirements.length,
+        verified_count: matrix.filter(m => m.verified).length,
+        validated_count: matrix.filter(m => m.validated).length,
+    };
+}
+/**
+ * Get a summary of a system's lifecycle status.
+ */
+function getLifecycleSummary(systemId) {
+    const system = systems.get(systemId);
+    if (!system) {
+        return {};
+    }
+    const checklistComplete = system.deploymentChecklist
+        .filter(item => item.required)
+        .every(item => item.completed);
+    const verifiedCount = system.verificationResults.filter(v => v.result === 'pass').length;
+    const validatedCount = system.validationResults.filter(v => v.result === 'pass').length;
+    return {
+        system_id: system.systemId,
+        name: system.name,
+        version: system.version,
+        stage: system.stage,
+        objectives_count: system.objectives.length,
+        objectives_achieved: system.objectives.filter(o => o.status === 'achieved').length,
+        documents_count: system.designDocuments.length,
+        requirements_count: system.requirements.length,
+        verified_requirements: verifiedCount,
+        validated_requirements: validatedCount,
+        deployment_plan_status: system.deploymentPlan?.approvalStatus || 'none',
+        checklist_items: system.deploymentChecklist.length,
+        checklist_complete: checklistComplete,
+        stage_transitions: system.stageHistory.length,
+    };
+}
+/**
+ * Get aggregate report of all system lifecycles.
+ */
+function getLifecycleReport(config) {
+    if (systems.size === 0) {
+        return {
+            total_systems: 0,
+            by_stage: {},
+            systems: [],
+        };
+    }
+    const byStage = {};
+    const systemsSummary = [];
+    systems.forEach(system => {
+        byStage[system.stage] = (byStage[system.stage] || 0) + 1;
+        systemsSummary.push({
+            system_id: system.systemId,
+            name: system.name,
+            version: system.version,
+            stage: system.stage,
+        });
+    });
+    return {
+        total_systems: systems.size,
+        by_stage: byStage,
+        systems: systemsSummary,
+    };
+}
+/**
+ * Emit a lifecycle event.
+ */
+function emitLifecycleEvent(system, eventType, config) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { getState } = require('./runtime');
+        const state = getState();
+        if (state && typeof state.emitInternal === 'function') {
+            state.emitInternal({
+                event_type: eventType,
+                timestamp: nowIso(),
+                body: systemRecordToDict(system),
+            });
+        }
+    }
+    catch (err) {
+        logger_1.logger.warning('Failed to emit lifecycle event:', err);
+    }
+}
+/**
+ * Emit the current state of a system record as an event.
+ */
+function emitSystemRecord(systemId, config) {
+    const system = getSystemRecord(systemId);
+    if (system) {
+        emitLifecycleEvent(system, 'system_lifecycle', config);
+    }
+}

package/dist/lineage.d.ts

@@ -5,13 +5,14 @@
  * automatic capture of parent events and input events in the trace graph.
  */
 import { AsyncLocalStorage } from 'async_hooks';
-interface LineageContext {
+export interface LineageContext {
     currentEventId: string | null;
     inputEventIds: string[];
     promptId: string | null;
     templateId: string | null;
     dataSourceIds: string[];
 }
+export declare function createLineageContext(): LineageContext;
 /**
  * Set the current event ID for lineage tracking.
  *
@@ -174,5 +175,4 @@ export declare function withPrompt<T extends (...args: any[]) => any>(options: {
  * @returns The AsyncLocalStorage instance.
  */
 export declare function getLineageStorage(): AsyncLocalStorage<LineageContext>;
-export {};
 //# sourceMappingURL=lineage.d.ts.map

package/dist/lineage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineage.d.ts","sourceRoot":"","sources":["../src/lineage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,UAAU,cAAc;IACtB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAuBD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAKrD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAGhD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAKnD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAQzC;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAKzD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,MAAM,GAAG,IAAI,CAG3C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAK7D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAG7C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAKpD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAQzC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAS1C;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAShD;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAS7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC1D,GAAG,QAAQ,EAAE,MAAM,EAAE,GACpB,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CASd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC/D,GAAG,SAAS,EAAE,MAAM,EAAE,GACrB,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CASd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,OAAO,EAAE;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAYf;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,iBAAiB,CAAC,cAAc,CAAC,CAErE"}
+{"version":3,"file":"lineage.d.ts","sourceRoot":"","sources":["../src/lineage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAoBD,wBAAgB,oBAAoB,IAAI,cAAc,CAQrD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAKrD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAGhD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAKnD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAQzC;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAKzD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,MAAM,GAAG,IAAI,CAG3C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAK7D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAG7C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAKpD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAQzC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAS1C;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAGhD;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAG7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC1D,GAAG,QAAQ,EAAE,MAAM,EAAE,GACpB,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CASd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC/D,GAAG,SAAS,EAAE,MAAM,EAAE,GACrB,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CASd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,OAAO,EAAE;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAYf;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,iBAAiB,CAAC,cAAc,CAAC,CAErE"}