aifastdb 3.8.9 → 3.10.0

package/dist/social-graph-v2.js

@@ -18,6 +18,622 @@ exports.ChangeTypes = exports.AnchorStatus = exports.AnchorTypes = exports.Memor
 exports.createSocialGraphV2 = createSocialGraphV2;
 exports.createHighThroughputSocialGraph = createHighThroughputSocialGraph;
 exports.createLowLatencySocialGraph = createLowLatencySocialGraph;
+function normalizeImportSession(raw) {
+    if (!raw)
+        return null;
+    return {
+        sessionId: raw.sessionId ?? raw.session_id,
+        datasetKey: raw.datasetKey ?? raw.dataset_key,
+        sourceName: raw.sourceName ?? raw.source_name,
+        importBatchId: raw.importBatchId ?? raw.import_batch_id,
+        mode: raw.mode,
+        status: raw.status,
+        startedAt: raw.startedAt ?? raw.started_at,
+        committedAt: raw.committedAt ?? raw.committed_at,
+        checkpointToken: raw.checkpointToken ?? raw.checkpoint_token,
+        metadata: raw.metadata,
+    };
+}
+function normalizeImportCheckpoint(raw) {
+    if (!raw)
+        return null;
+    return {
+        sessionId: raw.sessionId ?? raw.session_id,
+        checkpointToken: raw.checkpointToken ?? raw.checkpoint_token,
+        lastEntityCursor: raw.lastEntityCursor ?? raw.last_entity_cursor,
+        lastRelationCursor: raw.lastRelationCursor ?? raw.last_relation_cursor,
+        processedItems: raw.processedItems ?? raw.processed_items ?? 0,
+        createdItems: raw.createdItems ?? raw.created_items ?? 0,
+        updatedItems: raw.updatedItems ?? raw.updated_items ?? 0,
+        skippedItems: raw.skippedItems ?? raw.skipped_items ?? 0,
+        failedItems: raw.failedItems ?? raw.failed_items ?? 0,
+        createdAt: raw.createdAt ?? raw.created_at,
+        metadata: raw.metadata,
+    };
+}
+function normalizeBatchWriteResult(raw) {
+    return {
+        sessionId: raw?.sessionId ?? raw?.session_id,
+        batchId: raw?.batchId ?? raw?.batch_id,
+        success: raw?.success ?? false,
+        total: raw?.total ?? 0,
+        created: raw?.created ?? 0,
+        updated: raw?.updated ?? 0,
+        skipped: raw?.skipped ?? 0,
+        failed: raw?.failed ?? 0,
+        unchanged: raw?.unchanged ?? 0,
+        checkpointToken: raw?.checkpointToken ?? raw?.checkpoint_token,
+        items: (raw?.items ?? []).map((item) => ({
+            index: item.index,
+            itemType: item.itemType ?? item.item_type,
+            inputId: item.inputId ?? item.input_id,
+            resolvedId: item.resolvedId ?? item.resolved_id,
+            status: item.status,
+            reasonCode: item.reasonCode ?? item.reason_code,
+            message: item.message,
+            conflictPolicy: item.conflictPolicy ?? item.conflict_policy,
+            warnings: item.warnings,
+            diagnostics: item.diagnostics,
+        })),
+        stats: raw?.stats,
+        warnings: raw?.warnings,
+    };
+}
+function normalizeRelationEvidenceResult(raw) {
+    return {
+        relation: raw.relation,
+        evidenceEntities: raw.evidenceEntities ?? raw.evidence_entities ?? [],
+        sourceChapterId: raw.sourceChapterId ?? raw.source_chapter_id,
+        sourceChapterTitle: raw.sourceChapterTitle ?? raw.source_chapter_title,
+        sourceSpan: raw.sourceSpan ?? raw.source_span,
+        sourceQuote: raw.sourceQuote ?? raw.source_quote,
+    };
+}
+function normalizeSourceBundleResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        sourceEntity: raw.sourceEntity ?? raw.source_entity,
+        claims: raw.claims ?? [],
+        facts: raw.facts ?? [],
+        evidenceEntities: raw.evidenceEntities ?? raw.evidence_entities ?? [],
+    };
+}
+function normalizeHistoricalSourceExcerptResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        excerptId: raw.excerptId ?? raw.excerpt_id,
+        sourceEntity: raw.sourceEntity ?? raw.source_entity ?? null,
+        sourceChapterId: raw.sourceChapterId ?? raw.source_chapter_id,
+        sourceChapterTitle: raw.sourceChapterTitle ?? raw.source_chapter_title,
+        sourceSpan: raw.sourceSpan ?? raw.source_span,
+        sourceQuote: raw.sourceQuote ?? raw.source_quote,
+        relationIds: raw.relationIds ?? raw.relation_ids ?? [],
+        evidenceEntities: raw.evidenceEntities ?? raw.evidence_entities ?? [],
+        claimEntities: raw.claimEntities ?? raw.claim_entities ?? [],
+        factEntities: raw.factEntities ?? raw.fact_entities ?? [],
+        yearStart: raw.yearStart ?? raw.year_start,
+        yearEnd: raw.yearEnd ?? raw.year_end,
+        timeLabel: raw.timeLabel ?? raw.time_label,
+        dynasty: raw.dynasty,
+        supportCount: raw.supportCount ?? raw.support_count ?? 0,
+        reasonCodes: raw.reasonCodes ?? raw.reason_codes ?? [],
+    };
+}
+function normalizeHistoricalEvidenceContextSummaryResult(raw) {
+    return {
+        excerptCount: raw?.excerptCount ?? raw?.excerpt_count ?? 0,
+        quotedExcerptCount: raw?.quotedExcerptCount ?? raw?.quoted_excerpt_count ?? 0,
+        sourceEntityCount: raw?.sourceEntityCount ?? raw?.source_entity_count ?? 0,
+        relationCount: raw?.relationCount ?? raw?.relation_count ?? 0,
+        evidenceCount: raw?.evidenceCount ?? raw?.evidence_count ?? 0,
+        claimCount: raw?.claimCount ?? raw?.claim_count ?? 0,
+        factCount: raw?.factCount ?? raw?.fact_count ?? 0,
+    };
+}
+function normalizeHistoricalEvidenceContextResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        targetEntity: raw.targetEntity ?? raw.target_entity,
+        excerpts: (raw.excerpts ?? [])
+            .map(normalizeHistoricalSourceExcerptResult)
+            .filter(Boolean),
+        sourceEntities: raw.sourceEntities ?? raw.source_entities ?? [],
+        evidenceEntities: raw.evidenceEntities ?? raw.evidence_entities ?? [],
+        claimEntities: raw.claimEntities ?? raw.claim_entities ?? [],
+        factEntities: raw.factEntities ?? raw.fact_entities ?? [],
+        summary: normalizeHistoricalEvidenceContextSummaryResult(raw.summary),
+        reasons: raw.reasons ?? [],
+    };
+}
+function normalizeEntityHistoryBundleResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        entity: raw.entity,
+        relatedEntities: raw.relatedEntities ?? raw.related_entities ?? [],
+        timeline: raw.timeline ?? [],
+        evidence: (raw.evidence ?? []).map(normalizeRelationEvidenceResult),
+        claims: raw.claims ?? [],
+        facts: raw.facts ?? [],
+        chapters: raw.chapters ?? [],
+        conflictClusters: (raw.conflictClusters ?? raw.conflict_clusters ?? []).map(normalizeConflictClusterResult).filter(Boolean),
+        summary: {
+            relatedEntityCount: raw.summary?.relatedEntityCount ?? raw.summary?.related_entity_count ?? 0,
+            timelineCount: raw.summary?.timelineCount ?? raw.summary?.timeline_count ?? 0,
+            evidenceCount: raw.summary?.evidenceCount ?? raw.summary?.evidence_count ?? 0,
+            claimCount: raw.summary?.claimCount ?? raw.summary?.claim_count ?? 0,
+            factCount: raw.summary?.factCount ?? raw.summary?.fact_count ?? 0,
+            chapterCount: raw.summary?.chapterCount ?? raw.summary?.chapter_count ?? 0,
+            conflictClusterCount: raw.summary?.conflictClusterCount ?? raw.summary?.conflict_cluster_count ?? 0,
+            hasSourceBundle: raw.summary?.hasSourceBundle ?? raw.summary?.has_source_bundle ?? false,
+        },
+        sourceBundle: normalizeSourceBundleResult(raw.sourceBundle ?? raw.source_bundle),
+    };
+}
+function normalizeTimelineBucketResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        bucketKey: raw.bucketKey ?? raw.bucket_key,
+        yearStart: raw.yearStart ?? raw.year_start,
+        yearEnd: raw.yearEnd ?? raw.year_end,
+        timeLabel: raw.timeLabel ?? raw.time_label,
+        dynasty: raw.dynasty,
+        hits: raw.hits ?? [],
+        hitCount: raw.hitCount ?? raw.hit_count ?? 0,
+    };
+}
+function normalizeHistoricalTimelineEventResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        event: raw.event,
+        yearStart: raw.yearStart ?? raw.year_start,
+        yearEnd: raw.yearEnd ?? raw.year_end,
+        timeLabel: raw.timeLabel ?? raw.time_label,
+        dynasty: raw.dynasty,
+        participantCount: raw.participantCount ?? raw.participant_count ?? 0,
+        chapterCount: raw.chapterCount ?? raw.chapter_count ?? 0,
+        evidenceCount: raw.evidenceCount ?? raw.evidence_count ?? 0,
+        claimCount: raw.claimCount ?? raw.claim_count ?? 0,
+        factCount: raw.factCount ?? raw.fact_count ?? 0,
+        conflictClusterCount: raw.conflictClusterCount ?? raw.conflict_cluster_count ?? 0,
+    };
+}
+function normalizeHistoricalEventParticipantResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        participant: raw.participant,
+        relation: raw.relation,
+        role: raw.role,
+        stance: raw.stance,
+        side: raw.side,
+        narrativeWeight: raw.narrativeWeight ?? raw.narrative_weight,
+        sourceEntities: raw.sourceEntities ?? raw.source_entities ?? [],
+        evidenceEntities: raw.evidenceEntities ?? raw.evidence_entities ?? [],
+        yearStart: raw.yearStart ?? raw.year_start,
+        yearEnd: raw.yearEnd ?? raw.year_end,
+        timeLabel: raw.timeLabel ?? raw.time_label,
+        dynasty: raw.dynasty,
+    };
+}
+function normalizeHistoricalEntityEventRoleResult(raw) {
+    const event = normalizeHistoricalTimelineEventResult(raw?.event);
+    if (!raw || !event)
+        return null;
+    return {
+        event,
+        relation: raw.relation,
+        role: raw.role,
+        stance: raw.stance,
+        side: raw.side,
+        narrativeWeight: raw.narrativeWeight ?? raw.narrative_weight,
+        sourceEntities: raw.sourceEntities ?? raw.source_entities ?? [],
+        evidenceEntities: raw.evidenceEntities ?? raw.evidence_entities ?? [],
+    };
+}
+function normalizeHistoricalActorInteractionResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        counterpart: raw.counterpart,
+        interactionScore: raw.interactionScore ?? raw.interaction_score ?? 0,
+        coEventCount: raw.coEventCount ?? raw.co_event_count ?? 0,
+        conflictTouchCount: raw.conflictTouchCount ?? raw.conflict_touch_count ?? 0,
+        sharedSourceCount: raw.sharedSourceCount ?? raw.shared_source_count ?? 0,
+        timeOverlapScore: raw.timeOverlapScore ?? raw.time_overlap_score ?? 0,
+        directRelationCount: raw.directRelationCount ?? raw.direct_relation_count ?? 0,
+        relationTypes: raw.relationTypes ?? raw.relation_types ?? [],
+        sharedEventIds: raw.sharedEventIds ?? raw.shared_event_ids ?? [],
+        sourceEntities: raw.sourceEntities ?? raw.source_entities ?? [],
+        evidenceEntities: raw.evidenceEntities ?? raw.evidence_entities ?? [],
+        reasons: raw.reasons ?? [],
+    };
+}
+function normalizeHistoricalInteractionSummaryStatsResult(raw) {
+    return {
+        counterpartCount: raw?.counterpartCount ?? raw?.counterpart_count ?? 0,
+        personCounterpartCount: raw?.personCounterpartCount ?? raw?.person_counterpart_count ?? 0,
+        eventCounterpartCount: raw?.eventCounterpartCount ?? raw?.event_counterpart_count ?? 0,
+        directRelationCount: raw?.directRelationCount ?? raw?.direct_relation_count ?? 0,
+        coEventCount: raw?.coEventCount ?? raw?.co_event_count ?? 0,
+        conflictTouchCount: raw?.conflictTouchCount ?? raw?.conflict_touch_count ?? 0,
+        sharedSourceCount: raw?.sharedSourceCount ?? raw?.shared_source_count ?? 0,
+        strongestInteractionScore: raw?.strongestInteractionScore ?? raw?.strongest_interaction_score ?? 0,
+        averageInteractionScore: raw?.averageInteractionScore ?? raw?.average_interaction_score ?? 0,
+    };
+}
+function normalizeHistoricalInteractionSummaryResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        anchorEntity: raw.anchorEntity ?? raw.anchor_entity,
+        interactions: (raw.interactions ?? [])
+            .map(normalizeHistoricalActorInteractionResult)
+            .filter(Boolean),
+        strongestPersonInteraction: normalizeHistoricalActorInteractionResult(raw.strongestPersonInteraction ?? raw.strongest_person_interaction),
+        strongestEventInteraction: normalizeHistoricalActorInteractionResult(raw.strongestEventInteraction ?? raw.strongest_event_interaction),
+        summary: normalizeHistoricalInteractionSummaryStatsResult(raw.summary),
+        reasons: raw.reasons ?? [],
+    };
+}
+function normalizeHistoricalActivityItemResult(raw) {
+    const event = normalizeHistoricalTimelineEventResult(raw?.event);
+    if (!raw)
+        return null;
+    return {
+        activityId: raw.activityId ?? raw.activity_id,
+        activityType: raw.activityType ?? raw.activity_type,
+        primaryEntity: raw.primaryEntity ?? raw.primary_entity,
+        relatedEntities: raw.relatedEntities ?? raw.related_entities ?? [],
+        sourceEntities: raw.sourceEntities ?? raw.source_entities ?? [],
+        evidenceEntities: raw.evidenceEntities ?? raw.evidence_entities ?? [],
+        relation: raw.relation ?? null,
+        event,
+        yearStart: raw.yearStart ?? raw.year_start,
+        yearEnd: raw.yearEnd ?? raw.year_end,
+        timeLabel: raw.timeLabel ?? raw.time_label,
+        dynasty: raw.dynasty,
+        importanceScore: raw.importanceScore ?? raw.importance_score ?? null,
+        conflictStatus: raw.conflictStatus ?? raw.conflict_status ?? null,
+        reasonCodes: raw.reasonCodes ?? raw.reason_codes ?? [],
+    };
+}
+function normalizeHistoricalActivityStreamResult(raw) {
+    if (!raw)
+        return null;
+    const summary = raw.summary ?? {};
+    return {
+        anchorEntity: raw.anchorEntity ?? raw.anchor_entity ?? null,
+        items: (raw.items ?? []).map(normalizeHistoricalActivityItemResult).filter(Boolean),
+        summary: {
+            activityCount: summary.activityCount ?? summary.activity_count ?? 0,
+            eventCount: summary.eventCount ?? summary.event_count ?? 0,
+            relationCount: summary.relationCount ?? summary.relation_count ?? 0,
+            claimCount: summary.claimCount ?? summary.claim_count ?? 0,
+            factCount: summary.factCount ?? summary.fact_count ?? 0,
+            evidenceCount: summary.evidenceCount ?? summary.evidence_count ?? 0,
+            conflictCount: summary.conflictCount ?? summary.conflict_count ?? 0,
+        },
+    };
+}
+function normalizeHistoricalEventImportanceScoreBreakdownResult(raw) {
+    return {
+        participantScore: raw?.participantScore ?? raw?.participant_score ?? 0,
+        chapterScore: raw?.chapterScore ?? raw?.chapter_score ?? 0,
+        evidenceScore: raw?.evidenceScore ?? raw?.evidence_score ?? 0,
+        claimScore: raw?.claimScore ?? raw?.claim_score ?? 0,
+        factScore: raw?.factScore ?? raw?.fact_score ?? 0,
+        conflictScore: raw?.conflictScore ?? raw?.conflict_score ?? 0,
+        chronologyScore: raw?.chronologyScore ?? raw?.chronology_score ?? 0,
+    };
+}
+function normalizeHistoricalEventImportanceResult(raw) {
+    const event = normalizeHistoricalTimelineEventResult(raw?.event);
+    if (!raw || !event)
+        return null;
+    return {
+        event,
+        score: raw.score ?? 0,
+        reasons: raw.reasons ?? [],
+        scoreBreakdown: normalizeHistoricalEventImportanceScoreBreakdownResult(raw.scoreBreakdown ?? raw.score_breakdown),
+    };
+}
+function normalizeHistoricalNarrativeOrderResult(raw) {
+    const event = normalizeHistoricalTimelineEventResult(raw?.event);
+    if (!raw || !event)
+        return null;
+    const scoreBreakdownRaw = raw.scoreBreakdown ?? raw.score_breakdown ?? {};
+    const scoreBreakdown = {
+        chronologyScore: scoreBreakdownRaw.chronologyScore ?? scoreBreakdownRaw.chronology_score ?? 0,
+        supportDensityScore: scoreBreakdownRaw.supportDensityScore ?? scoreBreakdownRaw.support_density_score ?? 0,
+        excerptSignalScore: scoreBreakdownRaw.excerptSignalScore ?? scoreBreakdownRaw.excerpt_signal_score ?? 0,
+        narrativeSignalScore: scoreBreakdownRaw.narrativeSignalScore ?? scoreBreakdownRaw.narrative_signal_score ?? 0,
+        anchorRelevanceScore: scoreBreakdownRaw.anchorRelevanceScore ?? scoreBreakdownRaw.anchor_relevance_score ?? 0,
+    };
+    return {
+        event,
+        score: raw.score ?? 0,
+        reasons: raw.reasons ?? [],
+        scoreBreakdown,
+    };
+}
+function normalizeHistoricalTimelineBucketResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        bucketKey: raw.bucketKey ?? raw.bucket_key,
+        yearStart: raw.yearStart ?? raw.year_start,
+        yearEnd: raw.yearEnd ?? raw.year_end,
+        timeLabel: raw.timeLabel ?? raw.time_label,
+        dynasty: raw.dynasty,
+        events: (raw.events ?? []).map(normalizeHistoricalTimelineEventResult).filter(Boolean),
+        eventCount: raw.eventCount ?? raw.event_count ?? 0,
+        participantCount: raw.participantCount ?? raw.participant_count ?? 0,
+    };
+}
+function normalizeHistoricalEntitySpotlightResult(raw) {
+    if (!raw)
+        return null;
+    const summary = raw.summary ?? {};
+    return {
+        entity: raw.entity,
+        canonicalEntity: raw.canonicalEntity ?? raw.canonical_entity,
+        aliasEntities: raw.aliasEntities ?? raw.alias_entities ?? [],
+        bundle: normalizeEntityHistoryBundleResult(raw.bundle),
+        kinshipRelations: raw.kinshipRelations ?? raw.kinship_relations ?? [],
+        politicalRelations: raw.politicalRelations ?? raw.political_relations ?? [],
+        eventRelations: raw.eventRelations ?? raw.event_relations ?? [],
+        summary: {
+            aliasCount: summary.aliasCount ?? summary.alias_count ?? 0,
+            kinshipRelationCount: summary.kinshipRelationCount ?? summary.kinship_relation_count ?? 0,
+            politicalRelationCount: summary.politicalRelationCount ?? summary.political_relation_count ?? 0,
+            eventRelationCount: summary.eventRelationCount ?? summary.event_relation_count ?? 0,
+            chapterCount: summary.chapterCount ?? summary.chapter_count ?? 0,
+            timelineCount: summary.timelineCount ?? summary.timeline_count ?? 0,
+            conflictClusterCount: summary.conflictClusterCount ?? summary.conflict_cluster_count ?? 0,
+        },
+    };
+}
+function normalizeHistoricalConflictOverviewResult(raw) {
+    if (!raw)
+        return null;
+    const summary = raw.summary ?? {};
+    return {
+        entity: raw.entity,
+        clusters: (raw.clusters ?? []).map(normalizeConflictClusterResult).filter(Boolean),
+        sourceEntities: raw.sourceEntities ?? raw.source_entities ?? [],
+        evidenceEntities: raw.evidenceEntities ?? raw.evidence_entities ?? [],
+        summary: {
+            clusterCount: summary.clusterCount ?? summary.cluster_count ?? 0,
+            claimEntityCount: summary.claimEntityCount ?? summary.claim_entity_count ?? 0,
+            factEntityCount: summary.factEntityCount ?? summary.fact_entity_count ?? 0,
+            sourceEntityCount: summary.sourceEntityCount ?? summary.source_entity_count ?? 0,
+            evidenceEntityCount: summary.evidenceEntityCount ?? summary.evidence_entity_count ?? 0,
+            dominantLevels: summary.dominantLevels ?? summary.dominant_levels ?? [],
+            conflictKinds: summary.conflictKinds ?? summary.conflict_kinds ?? [],
+        },
+    };
+}
+function normalizeHistoricalConflictScoreBreakdownResult(raw) {
+    return {
+        structuralScore: raw?.structuralScore ?? raw?.structural_score ?? 0,
+        evidenceScore: raw?.evidenceScore ?? raw?.evidence_score ?? 0,
+        sourceScore: raw?.sourceScore ?? raw?.source_score ?? 0,
+        factPriorityScore: raw?.factPriorityScore ?? raw?.fact_priority_score ?? 0,
+        kindDiversityScore: raw?.kindDiversityScore ?? raw?.kind_diversity_score ?? 0,
+        spreadScore: raw?.spreadScore ?? raw?.spread_score ?? 0,
+    };
+}
+function normalizeHistoricalConflictAdjudicationResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        scope: raw.scope,
+        targetId: raw.targetId ?? raw.target_id,
+        score: raw.score ?? 0,
+        severity: raw.severity ?? 'low',
+        status: raw.status ?? 'monitor',
+        recommendedAction: raw.recommendedAction ?? raw.recommended_action ?? 'monitor_conflicts',
+        reasons: raw.reasons ?? [],
+        scoreBreakdown: normalizeHistoricalConflictScoreBreakdownResult(raw.scoreBreakdown ?? raw.score_breakdown),
+    };
+}
+function normalizeHistoricalConflictAdjudicationContainerResult(raw) {
+    const overview = normalizeHistoricalConflictOverviewResult(raw?.overview);
+    const overviewAssessment = normalizeHistoricalConflictAdjudicationResult(raw?.overviewAssessment ?? raw?.overview_assessment);
+    if (!raw || !overview || !overviewAssessment)
+        return null;
+    return {
+        entity: raw.entity,
+        overview,
+        overviewAssessment,
+        clusterAssessments: (raw.clusterAssessments ?? raw.cluster_assessments ?? [])
+            .map(normalizeHistoricalConflictAdjudicationResult)
+            .filter(Boolean),
+    };
+}
+function normalizeHistoricalGraphDiagnosticsResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        counts: {
+            historicalEntityCount: raw.counts?.historicalEntityCount ?? raw.counts?.historical_entity_count ?? 0,
+            historicalRelationCount: raw.counts?.historicalRelationCount ?? raw.counts?.historical_relation_count ?? 0,
+            personCount: raw.counts?.personCount ?? raw.counts?.person_count ?? 0,
+            eventCount: raw.counts?.eventCount ?? raw.counts?.event_count ?? 0,
+            documentCount: raw.counts?.documentCount ?? raw.counts?.document_count ?? 0,
+            evidenceCount: raw.counts?.evidenceCount ?? raw.counts?.evidence_count ?? 0,
+            claimCount: raw.counts?.claimCount ?? raw.counts?.claim_count ?? 0,
+            factCount: raw.counts?.factCount ?? raw.counts?.fact_count ?? 0,
+        },
+        timeCoverage: {
+            datedEntityCount: raw.timeCoverage?.datedEntityCount ?? raw.time_coverage?.dated_entity_count ?? 0,
+            undatedEntityCount: raw.timeCoverage?.undatedEntityCount ?? raw.time_coverage?.undated_entity_count ?? 0,
+            datedEventCount: raw.timeCoverage?.datedEventCount ?? raw.time_coverage?.dated_event_count ?? 0,
+            undatedEventCount: raw.timeCoverage?.undatedEventCount ?? raw.time_coverage?.undated_event_count ?? 0,
+            datedRelationCount: raw.timeCoverage?.datedRelationCount ?? raw.time_coverage?.dated_relation_count ?? 0,
+            undatedRelationCount: raw.timeCoverage?.undatedRelationCount ?? raw.time_coverage?.undated_relation_count ?? 0,
+        },
+        integrity: {
+            danglingRelationEndpointCount: raw.integrity?.danglingRelationEndpointCount ?? raw.integrity?.dangling_relation_endpoint_count ?? 0,
+            danglingSourceEntityRefCount: raw.integrity?.danglingSourceEntityRefCount ?? raw.integrity?.dangling_source_entity_ref_count ?? 0,
+            danglingEvidenceRefCount: raw.integrity?.danglingEvidenceRefCount ?? raw.integrity?.dangling_evidence_ref_count ?? 0,
+            danglingClaimRefCount: raw.integrity?.danglingClaimRefCount ?? raw.integrity?.dangling_claim_ref_count ?? 0,
+            danglingCanonicalEntityRefCount: raw.integrity?.danglingCanonicalEntityRefCount ?? raw.integrity?.dangling_canonical_entity_ref_count ?? 0,
+            danglingCanonicalFactRefCount: raw.integrity?.danglingCanonicalFactRefCount ?? raw.integrity?.dangling_canonical_fact_ref_count ?? 0,
+        },
+        metadataCompleteness: {
+            claimsMissingSubjectEntityCount: raw.metadataCompleteness?.claimsMissingSubjectEntityCount ?? raw.metadata_completeness?.claims_missing_subject_entity_count ?? 0,
+            claimsMissingRelationTypeCount: raw.metadataCompleteness?.claimsMissingRelationTypeCount ?? raw.metadata_completeness?.claims_missing_relation_type_count ?? 0,
+            factsMissingClaimIdsCount: raw.metadataCompleteness?.factsMissingClaimIdsCount ?? raw.metadata_completeness?.facts_missing_claim_ids_count ?? 0,
+            factsMissingEvidenceIdsCount: raw.metadataCompleteness?.factsMissingEvidenceIdsCount ?? raw.metadata_completeness?.facts_missing_evidence_ids_count ?? 0,
+            evidenceMissingReferencedEntityIdsCount: raw.metadataCompleteness?.evidenceMissingReferencedEntityIdsCount ?? raw.metadata_completeness?.evidence_missing_referenced_entity_ids_count ?? 0,
+            evidenceMissingSourceEntityCount: raw.metadataCompleteness?.evidenceMissingSourceEntityCount ?? raw.metadata_completeness?.evidence_missing_source_entity_count ?? 0,
+            relationsMissingRelationFamilyCount: raw.metadataCompleteness?.relationsMissingRelationFamilyCount ?? raw.metadata_completeness?.relations_missing_relation_family_count ?? 0,
+        },
+        metrics: {
+            totalRequests: raw.metrics?.totalRequests ?? raw.metrics?.total_requests ?? 0,
+            successfulWrites: raw.metrics?.successfulWrites ?? raw.metrics?.successful_writes ?? 0,
+            failedWrites: raw.metrics?.failedWrites ?? raw.metrics?.failed_writes ?? 0,
+            rejectedRequests: raw.metrics?.rejectedRequests ?? raw.metrics?.rejected_requests ?? 0,
+            batchesFlushed: raw.metrics?.batchesFlushed ?? raw.metrics?.batches_flushed ?? 0,
+            batchDocuments: raw.metrics?.batchDocuments ?? raw.metrics?.batch_documents ?? 0,
+            avgQueueTimeUs: raw.metrics?.avgQueueTimeUs ?? raw.metrics?.avg_queue_time_us ?? 0,
+            avgWriteTimeUs: raw.metrics?.avgWriteTimeUs ?? raw.metrics?.avg_write_time_us ?? 0,
+            entityCount: raw.metrics?.entityCount ?? raw.metrics?.entity_count ?? 0,
+            relationCount: raw.metrics?.relationCount ?? raw.metrics?.relation_count ?? 0,
+            queueFillRatio: raw.metrics?.queueFillRatio ?? raw.metrics?.queue_fill_ratio ?? 0,
+        },
+        issues: (raw.issues ?? []).map((issue) => ({
+            code: issue.code,
+            severity: issue.severity,
+            message: issue.message,
+            entityId: issue.entityId ?? issue.entity_id,
+            relationId: issue.relationId ?? issue.relation_id,
+        })),
+    };
+}
+function normalizeAliasMergeResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        canonicalEntity: raw.canonicalEntity ?? raw.canonical_entity,
+        aliasEntity: raw.aliasEntity ?? raw.alias_entity,
+        mergedAliasNames: raw.mergedAliasNames ?? raw.merged_alias_names ?? [],
+    };
+}
+function normalizeHistoricalGraphProjectionResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        rootEntity: raw.rootEntity ?? raw.root_entity,
+        entities: raw.entities ?? [],
+        relations: raw.relations ?? [],
+        timelineBuckets: (raw.timelineBuckets ?? raw.timeline_buckets ?? []).map(normalizeTimelineBucketResult).filter(Boolean),
+        summary: {
+            relatedEntityCount: raw.summary?.relatedEntityCount ?? raw.summary?.related_entity_count ?? 0,
+            timelineCount: raw.summary?.timelineCount ?? raw.summary?.timeline_count ?? 0,
+            evidenceCount: raw.summary?.evidenceCount ?? raw.summary?.evidence_count ?? 0,
+            claimCount: raw.summary?.claimCount ?? raw.summary?.claim_count ?? 0,
+            factCount: raw.summary?.factCount ?? raw.summary?.fact_count ?? 0,
+            chapterCount: raw.summary?.chapterCount ?? raw.summary?.chapter_count ?? 0,
+            conflictClusterCount: raw.summary?.conflictClusterCount ?? raw.summary?.conflict_cluster_count ?? 0,
+            hasSourceBundle: raw.summary?.hasSourceBundle ?? raw.summary?.has_source_bundle ?? false,
+        },
+        sections: {
+            relatedEntityIds: raw.sections?.relatedEntityIds ?? raw.sections?.related_entity_ids ?? [],
+            timelineEntityIds: raw.sections?.timelineEntityIds ?? raw.sections?.timeline_entity_ids ?? [],
+            claimIds: raw.sections?.claimIds ?? raw.sections?.claim_ids ?? [],
+            factIds: raw.sections?.factIds ?? raw.sections?.fact_ids ?? [],
+            chapterIds: raw.sections?.chapterIds ?? raw.sections?.chapter_ids ?? [],
+            evidenceEntityIds: raw.sections?.evidenceEntityIds ?? raw.sections?.evidence_entity_ids ?? [],
+            sourceEntityIds: raw.sections?.sourceEntityIds ?? raw.sections?.source_entity_ids ?? [],
+            conflictEntityIds: raw.sections?.conflictEntityIds ?? raw.sections?.conflict_entity_ids ?? [],
+            relationIds: raw.sections?.relationIds ?? raw.sections?.relation_ids ?? [],
+        },
+    };
+}
+function normalizeConflictClusterResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        anchorEntity: raw.anchorEntity ?? raw.anchor_entity,
+        clusterEntities: raw.clusterEntities ?? raw.cluster_entities ?? [],
+        conflictRelations: raw.conflictRelations ?? raw.conflict_relations ?? [],
+        relatedEntities: raw.relatedEntities ?? raw.related_entities ?? [],
+        sourceEntities: raw.sourceEntities ?? raw.source_entities ?? [],
+        evidenceEntities: raw.evidenceEntities ?? raw.evidence_entities ?? [],
+        conflictLevels: raw.conflictLevels ?? raw.conflict_levels ?? [],
+        conflictKinds: raw.conflictKinds ?? raw.conflict_kinds ?? [],
+        claimEntities: raw.claimEntities ?? raw.claim_entities ?? [],
+        factEntities: raw.factEntities ?? raw.fact_entities ?? [],
+        claimConflictRelations: raw.claimConflictRelations ?? raw.claim_conflict_relations ?? [],
+        factConflictRelations: raw.factConflictRelations ?? raw.fact_conflict_relations ?? [],
+        mixedConflictRelations: raw.mixedConflictRelations ?? raw.mixed_conflict_relations ?? [],
+        summary: {
+            dominantLevel: raw.summary?.dominantLevel ?? raw.summary?.dominant_level,
+            clusterEntityCount: raw.summary?.clusterEntityCount ?? raw.summary?.cluster_entity_count ?? 0,
+            claimEntityCount: raw.summary?.claimEntityCount ?? raw.summary?.claim_entity_count ?? 0,
+            factEntityCount: raw.summary?.factEntityCount ?? raw.summary?.fact_entity_count ?? 0,
+            claimConflictCount: raw.summary?.claimConflictCount ?? raw.summary?.claim_conflict_count ?? 0,
+            factConflictCount: raw.summary?.factConflictCount ?? raw.summary?.fact_conflict_count ?? 0,
+            mixedConflictCount: raw.summary?.mixedConflictCount ?? raw.summary?.mixed_conflict_count ?? 0,
+            sourceEntityCount: raw.summary?.sourceEntityCount ?? raw.summary?.source_entity_count ?? 0,
+            evidenceEntityCount: raw.summary?.evidenceEntityCount ?? raw.summary?.evidence_entity_count ?? 0,
+        },
+    };
+}
+function normalizeHistoricalEntityRecommendationResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        entity: raw.entity,
+        score: raw.score ?? 0,
+        reasons: raw.reasons ?? [],
+    };
+}
+function normalizePathResult(raw) {
+    if (!raw)
+        return null;
+    return {
+        path: raw.path ?? [],
+        hops: raw.hops ?? 0,
+        intermediaries: raw.intermediaries ?? [],
+        relationChain: raw.relationChain ?? raw.relation_chain ?? [],
+    };
+}
+function normalizeAllPathsResult(raw) {
+    return {
+        paths: (raw?.paths ?? []).map(normalizePathResult).filter(Boolean),
+        shortestHops: raw?.shortestHops ?? raw?.shortest_hops ?? 0,
+    };
+}
+function normalizeHistoricalPathScoreBreakdownResult(raw) {
+    return {
+        hopScore: raw?.hopScore ?? raw?.hop_score ?? 0,
+        relationWeightScore: raw?.relationWeightScore ?? raw?.relation_weight_score ?? 0,
+        confidenceScore: raw?.confidenceScore ?? raw?.confidence_score ?? 0,
+        provenanceScore: raw?.provenanceScore ?? raw?.provenance_score ?? 0,
+        chronologyScore: raw?.chronologyScore ?? raw?.chronology_score ?? 0,
+        inferredPenalty: raw?.inferredPenalty ?? raw?.inferred_penalty ?? 0,
+    };
+}
+function normalizeHistoricalPathRankingResult(raw) {
+    const path = normalizePathResult(raw?.path);
+    if (!raw || !path)
+        return null;
+    return {
+        path,
+        score: raw.score ?? 0,
+        reasons: raw.reasons ?? [],
+        scoreBreakdown: normalizeHistoricalPathScoreBreakdownResult(raw.scoreBreakdown ?? raw.score_breakdown),
+    };
+}
 // ============================================================================
 // Main SocialGraphV2 Class
 // ============================================================================
@@ -204,6 +820,16 @@ class SocialGraphV2 {
     async addPersonAsync(input) {
         return this.native.addPersonAsync(input);
     }
+    /**
+     * Add a new person (async, fire-and-forget — maximum throughput)
+     *
+     * Enqueues the write and returns immediately. Does NOT wait for WAL persistence.
+     * Use when eventual consistency is acceptable and throughput is the priority.
+     * Call `flush()` / `save()` afterwards to ensure all writes are persisted.
+     */
+    async addPersonFast(input) {
+        return this.native.addPersonFast(input);
+    }
     /**
      * Update a person (async)
      */
@@ -258,6 +884,15 @@ class SocialGraphV2 {
     async addFriendAsync(personA, personB, config) {
         return this.native.addFriendAsync(personA, personB, config);
     }
+    /**
+     * Add a friend relationship (async, fire-and-forget — maximum throughput)
+     *
+     * Enqueues the write and returns immediately. Does NOT wait for WAL persistence.
+     * Call `flush()` / `save()` afterwards to ensure persistence.
+     */
+    async addFriendFast(personA, personB, config) {
+        return this.native.addFriendFast(personA, personB, config);
+    }
     /**
      * Remove a friend relationship (async)
      */
@@ -1225,6 +1860,403 @@ class SocialGraphV2 {
     putRelation(sourceId, targetId, relationType, weight, bidirectional) {
         return this.native.putRelation(sourceId, targetId, relationType, weight, bidirectional);
     }
+    /**
+     * Begin a logical historical graph import session.
+     */
+    beginImportSession(input) {
+        return normalizeImportSession(this.native.beginImportSession(input));
+    }
+    /**
+     * Commit a logical historical graph import session.
+     */
+    commitImportSession(sessionId) {
+        return normalizeImportSession(this.native.commitImportSession(sessionId));
+    }
+    /**
+     * Roll back a logical historical graph import session.
+     */
+    rollbackImportSession(sessionId) {
+        return normalizeImportSession(this.native.rollbackImportSession(sessionId));
+    }
+    /**
+     * Read the latest or a specific import checkpoint for a historical graph import session.
+     */
+    getImportCheckpoint(sessionId, checkpointToken) {
+        const raw = checkpointToken === undefined
+            ? this.native.getImportCheckpoint(sessionId)
+            : this.native.getImportCheckpoint(sessionId, checkpointToken);
+        return normalizeImportCheckpoint(raw);
+    }
+    /**
+     * Resume a historical graph import session from the latest or a specific checkpoint.
+     */
+    resumeImportSession(sessionId, checkpointToken) {
+        const raw = checkpointToken === undefined
+            ? this.native.resumeImportSession(sessionId)
+            : this.native.resumeImportSession(sessionId, checkpointToken);
+        return normalizeImportSession(raw);
+    }
+    /**
+     * Add a first-class historical claim node.
+     */
+    addHistoricalClaim(input) {
+        return this.native.addHistoricalClaim(input) ?? null;
+    }
+    /**
+     * Add a first-class historical fact node.
+     */
+    addHistoricalFact(input) {
+        return this.native.addHistoricalFact(input) ?? null;
+    }
+    /**
+     * Add a first-class historical evidence node.
+     */
+    addHistoricalEvidence(input) {
+        return this.native.addHistoricalEvidence(input) ?? null;
+    }
+    /**
+     * Add a historical conflict relation between claim/fact nodes.
+     */
+    addHistoricalConflict(input) {
+        return this.native.addHistoricalConflict(input) ?? null;
+    }
+    /**
+     * List claim nodes using the shared claim/fact/evidence filter contract.
+     */
+    listHistoricalClaims(filter) {
+        return this.native.listHistoricalClaims(filter);
+    }
+    /**
+     * List fact nodes using the shared claim/fact/evidence filter contract.
+     */
+    listHistoricalFacts(filter) {
+        return this.native.listHistoricalFacts(filter);
+    }
+    /**
+     * List evidence nodes using the shared claim/fact/evidence filter contract.
+     */
+    listHistoricalEvidence(filter) {
+        return this.native.listHistoricalEvidence(filter);
+    }
+    /**
+     * Get claim nodes emitted from a source/document entity.
+     */
+    getClaimsBySource(sourceEntityId, filter) {
+        return this.native.getClaimsBySource(sourceEntityId, filter);
+    }
+    /**
+     * Get fact nodes emitted from a source/document entity.
+     */
+    getFactsBySource(sourceEntityId, filter) {
+        return this.native.getFactsBySource(sourceEntityId, filter);
+    }
+    /**
+     * Get evidence nodes emitted from a source/document entity.
+     */
+    getEvidenceBySource(sourceEntityId, filter) {
+        return this.native.getEvidenceBySource(sourceEntityId, filter);
+    }
+    /**
+     * Get grouped source excerpts supporting an entity-centered historical view.
+     */
+    getHistoricalSourceExcerptsForEntity(entityId, filter) {
+        return this.native
+            .getHistoricalSourceExcerptsForEntity(entityId, filter)
+            .map(normalizeHistoricalSourceExcerptResult)
+            .filter(Boolean);
+    }
+    /**
+     * Get grouped source excerpts supporting an event-centered historical view.
+     */
+    getHistoricalSourceExcerptsForEvent(eventId, filter) {
+        return this.native
+            .getHistoricalSourceExcerptsForEvent(eventId, filter)
+            .map(normalizeHistoricalSourceExcerptResult)
+            .filter(Boolean);
+    }
+    /**
+     * Summarize source excerpts and supporting material around a target historical entity.
+     */
+    summarizeHistoricalEvidenceContext(entityId, filter) {
+        return normalizeHistoricalEvidenceContextResult(this.native.summarizeHistoricalEvidenceContext(entityId, filter));
+    }
+    /**
+     * Get claim nodes citing a specific evidence node.
+     */
+    getClaimsByEvidence(evidenceId, filter) {
+        return this.native.getClaimsByEvidence(evidenceId, filter);
+    }
+    /**
+     * Get fact nodes citing a specific evidence node.
+     */
+    getFactsByEvidence(evidenceId, filter) {
+        return this.native.getFactsByEvidence(evidenceId, filter);
+    }
+    /**
+     * Refresh a relation's lightweight metadata summary from claim/fact nodes.
+     */
+    syncHistoricalRelationSummary(relationId) {
+        return this.native.syncHistoricalRelationSummary(relationId) ?? null;
+    }
+    /**
+     * Refresh lightweight relation metadata summaries in bulk.
+     */
+    backfillHistoricalRelationSummaries(filter) {
+        return this.native.backfillHistoricalRelationSummaries(filter);
+    }
+    /**
+     * Add a historical entity using the standardized Phase-317 contract.
+     */
+    addHistoricalEntity(input) {
+        return this.native.addHistoricalEntity(input) ?? null;
+    }
+    /**
+     * Add multiple historical entities using the standardized Phase-317 contract.
+     */
+    addHistoricalEntitiesBatch(inputs) {
+        return this.native.addHistoricalEntitiesBatch(inputs);
+    }
+    /**
+     * Add multiple historical entities and receive detailed batch diagnostics.
+     */
+    addHistoricalEntitiesBatchDetailed(inputs, options, sessionId) {
+        return normalizeBatchWriteResult(this.native.addHistoricalEntitiesBatchDetailed(inputs, options, sessionId));
+    }
+    /**
+     * Add a historical relation using the standardized Phase-316 contract.
+     */
+    addHistoricalRelation(input) {
+        return this.native.addHistoricalRelation(input) ?? null;
+    }
+    /**
+     * Add multiple historical relations using the standardized Phase-316 contract.
+     */
+    addHistoricalRelationsBatch(inputs) {
+        return this.native.addHistoricalRelationsBatch(inputs);
+    }
+    /**
+     * Add multiple historical relations and receive detailed batch diagnostics.
+     */
+    addHistoricalRelationsBatchDetailed(inputs, options, sessionId) {
+        return normalizeBatchWriteResult(this.native.addHistoricalRelationsBatchDetailed(inputs, options, sessionId));
+    }
+    /**
+     * Get related entities for any entity using the advanced historical filter contract.
+     */
+    getRelatedEntities(entityId, filter) {
+        return this.native.getRelatedEntities(entityId, filter);
+    }
+    /**
+     * Get timeline-oriented related entities for any entity.
+     */
+    getEntityTimeline(entityId, filter) {
+        return this.native.getEntityTimeline(entityId, filter);
+    }
+    /**
+     * Get grouped timeline buckets for any entity.
+     */
+    getEntityTimelineBuckets(entityId, filter) {
+        return this.native.getEntityTimelineBuckets(entityId, filter).map(normalizeTimelineBucketResult).filter(Boolean);
+    }
+    /**
+     * Get globally ordered historical events with summary counts for timeline exploration.
+     */
+    getHistoricalEventTimeline(filter) {
+        return this.native.getHistoricalEventTimeline(filter).map(normalizeHistoricalTimelineEventResult).filter(Boolean);
+    }
+    /**
+     * Project a global historical activity stream across events, relations, provenance, and conflicts.
+     */
+    getHistoricalActivityStream(filter) {
+        return normalizeHistoricalActivityStreamResult(this.native.getHistoricalActivityStream(filter));
+    }
+    /**
+     * Get grouped buckets for the global historical event timeline.
+     */
+    getHistoricalEventTimelineBuckets(filter) {
+        return this.native.getHistoricalEventTimelineBuckets(filter).map(normalizeHistoricalTimelineBucketResult).filter(Boolean);
+    }
+    /**
+     * Score historical events with deterministic importance breakdowns.
+     */
+    scoreHistoricalEvents(filter) {
+        return this.native.scoreHistoricalEvents(filter).map(normalizeHistoricalEventImportanceResult).filter(Boolean);
+    }
+    /**
+     * Order historical events by chronology first, then narrative sequencing signals.
+     */
+    orderHistoricalNarrativeTimeline(filter) {
+        return this.native
+            .orderHistoricalNarrativeTimeline(filter)
+            .map(normalizeHistoricalNarrativeOrderResult)
+            .filter(Boolean);
+    }
+    /**
+     * Get evidence bundles for all relations touching an entity.
+     */
+    getEntityEvidence(entityId, filter) {
+        return this.native.getEntityEvidence(entityId, filter).map(normalizeRelationEvidenceResult);
+    }
+    /**
+     * List relations using the advanced historical filter contract.
+     */
+    listRelationsAdvanced(filter) {
+        return this.native.listRelationsAdvanced(filter);
+    }
+    /**
+     * Get related entities connected by the provided relation types.
+     */
+    getRelatedEntitiesByTypes(entityId, relationTypes, filter) {
+        return this.native.getRelatedEntitiesByTypes(entityId, relationTypes, filter);
+    }
+    /**
+     * Get event hits associated with a person.
+     */
+    getEventsByPerson(personId, filter) {
+        return this.native.getEventsByPerson(personId, filter);
+    }
+    /**
+     * Get person hits associated with an event.
+     */
+    getPersonsByEvent(eventId, filter) {
+        return this.native.getPersonsByEvent(eventId, filter);
+    }
+    /**
+     * Get role-aware participant rows for an event.
+     */
+    getHistoricalEventParticipants(eventId, filter) {
+        return this.native
+            .getHistoricalEventParticipants(eventId, filter)
+            .map(normalizeHistoricalEventParticipantResult)
+            .filter(Boolean);
+    }
+    /**
+     * Get role-aware event participation rows for an entity.
+     */
+    getEntityEventRoles(entityId, filter) {
+        return this.native
+            .getEntityEventRoles(entityId, filter)
+            .map(normalizeHistoricalEntityEventRoleResult)
+            .filter(Boolean);
+    }
+    /**
+     * Rank historical actors/events by interaction strength around an anchor entity.
+     */
+    rankHistoricalActorInteractions(entityId, filter) {
+        return this.native
+            .rankHistoricalActorInteractions(entityId, filter)
+            .map(normalizeHistoricalActorInteractionResult)
+            .filter(Boolean);
+    }
+    /**
+     * Build a summary view over ranked historical interactions for an anchor entity.
+     */
+    getHistoricalInteractionSummary(entityId, filter) {
+        return normalizeHistoricalInteractionSummaryResult(this.native.getHistoricalInteractionSummary(entityId, filter));
+    }
+    /**
+     * Get chapter/document hits associated with an entity.
+     */
+    getChaptersByEntity(entityId, filter) {
+        return this.native.getChaptersByEntity(entityId, filter);
+    }
+    /**
+     * Resolve evidence entities and inline source metadata for a relation.
+     */
+    getEvidenceForRelation(relationId) {
+        const raw = this.native.getEvidenceForRelation(relationId);
+        return raw ? normalizeRelationEvidenceResult(raw) : null;
+    }
+    /**
+     * Get claim nodes related to an entity.
+     */
+    getEntityClaims(entityId) {
+        return this.native.getEntityClaims(entityId);
+    }
+    /**
+     * Get fact nodes related to an entity.
+     */
+    getEntityFacts(entityId) {
+        return this.native.getEntityFacts(entityId);
+    }
+    /**
+     * Resolve an entity to its canonical entity, following canonical links when present.
+     */
+    resolveCanonicalEntity(entityId) {
+        return this.native.resolveCanonicalEntity(entityId);
+    }
+    /**
+     * List alias entities that currently point at a canonical entity.
+     */
+    getAliasEntities(canonicalEntityId) {
+        return this.native.getAliasEntities(canonicalEntityId);
+    }
+    /**
+     * Merge alias metadata into a canonical entity and link the alias entity to it.
+     */
+    mergeEntityAlias(canonicalEntityId, aliasEntityId) {
+        return normalizeAliasMergeResult(this.native.mergeEntityAlias(canonicalEntityId, aliasEntityId));
+    }
+    /**
+     * Get a grouped source bundle containing claim/fact/evidence nodes.
+     */
+    getSourceBundle(sourceEntityId) {
+        return normalizeSourceBundleResult(this.native.getSourceBundle(sourceEntityId));
+    }
+    /**
+     * Get an aggregated entity-centered historical graph bundle.
+     */
+    getEntityHistoryBundle(entityId, filter) {
+        return normalizeEntityHistoryBundleResult(this.native.getEntityHistoryBundle(entityId, filter));
+    }
+    /**
+     * Project an entity-centered historical activity stream.
+     */
+    getEntityHistoricalActivityStream(entityId, filter) {
+        return normalizeHistoricalActivityStreamResult(this.native.getEntityHistoricalActivityStream(entityId, filter));
+    }
+    /**
+     * Export an entity-centered historical projection with section metadata for view rendering.
+     */
+    exportEntityHistoryProjection(entityId, filter) {
+        return normalizeHistoricalGraphProjectionResult(this.native.exportEntityHistoryProjection(entityId, filter));
+    }
+    /**
+     * Get a product-facing spotlight view for an entity's historical universe.
+     */
+    getHistoricalEntitySpotlight(entityId, filter) {
+        return normalizeHistoricalEntitySpotlightResult(this.native.getHistoricalEntitySpotlight(entityId, filter));
+    }
+    /**
+     * Get the connected conflict component rooted at a claim/fact node.
+     */
+    getConflictCluster(entityId, filter) {
+        return normalizeConflictClusterResult(this.native.getConflictCluster(entityId, filter));
+    }
+    /**
+     * Get conflict clusters touching any claim/fact linked to an entity.
+     */
+    getEntityConflictClusters(entityId, filter) {
+        return this.native.getEntityConflictClusters(entityId, filter).map(normalizeConflictClusterResult).filter(Boolean);
+    }
+    /**
+     * Get an entity-level overview across conflict clusters, sources, and evidence.
+     */
+    getHistoricalConflictOverview(entityId, filter) {
+        return normalizeHistoricalConflictOverviewResult(this.native.getHistoricalConflictOverview(entityId, filter));
+    }
+    /**
+     * Build an entity-level conflict adjudication container with overview and per-cluster actions.
+     */
+    adjudicateHistoricalConflicts(entityId, filter) {
+        return normalizeHistoricalConflictAdjudicationContainerResult(this.native.adjudicateHistoricalConflicts(entityId, filter));
+    }
+    /**
+     * Build a global diagnostics report for the historical graph slice.
+     */
+    getHistoricalGraphDiagnostics() {
+        return normalizeHistoricalGraphDiagnosticsResult(this.native.getHistoricalGraphDiagnostics());
+    }
     // ========================================================================
     // Batch Operations (High Throughput)
     // ========================================================================
@@ -1652,7 +2684,28 @@ class SocialGraphV2 {
      * @param maxPaths Maximum number of paths (default: 10)
      */
     findAllPaths(fromId, toId, maxHops, maxPaths) {
-        return this.native.findAllPaths(fromId, toId, maxHops, maxPaths);
+        return normalizeAllPathsResult(this.native.findAllPaths(fromId, toId, maxHops, maxPaths));
+    }
+    /**
+     * Find all paths constrained by the historical relation filter contract.
+     */
+    findPathsWithRelationFilter(fromId, toId, filter, maxPaths) {
+        return normalizeAllPathsResult(this.native.findPathsWithRelationFilter(fromId, toId, filter, maxPaths));
+    }
+    /**
+     * Find all paths constrained by a historical time window.
+     */
+    findPathsWithTimeWindow(fromId, toId, yearStart, yearEnd, filter, maxPaths) {
+        return normalizeAllPathsResult(this.native.findPathsWithTimeWindow(fromId, toId, yearStart, yearEnd, filter, maxPaths));
+    }
+    /**
+     * Rank historical paths using provenance-aware scoring.
+     */
+    rankHistoricalPaths(fromId, toId, filter, maxPaths) {
+        return this.native
+            .rankHistoricalPaths(fromId, toId, filter, maxPaths)
+            .map(normalizeHistoricalPathRankingResult)
+            .filter(Boolean);
     }
     /**
      * Find intermediaries who can connect two persons
@@ -1875,6 +2928,12 @@ class SocialGraphV2 {
     searchEntitiesByVector(embedding, k, entityTypeFilter) {
         return this.native.searchEntitiesByVector(embedding, k, entityTypeFilter);
     }
+    /**
+     * Search historical entities by vector similarity using historical filters.
+     */
+    searchHistoricalEntitiesByVector(embedding, k, filter) {
+        return this.native.searchHistoricalEntitiesByVector(embedding, k, filter);
+    }
     /**
      * Hybrid search combining vector similarity and text attribute matching.
      *
@@ -1902,6 +2961,21 @@ class SocialGraphV2 {
     hybridSearch(embedding, textQuery, k, entityTypeFilter) {
         return this.native.hybridSearch(embedding, textQuery, k, entityTypeFilter);
     }
+    /**
+     * Hybrid search historical entities using vector and/or text signals.
+     */
+    hybridSearchHistoricalEntities(embedding, textQuery, k, filter) {
+        return this.native.hybridSearchHistoricalEntities(embedding, textQuery, k, filter);
+    }
+    /**
+     * Recommend related historical entities from the entity-centered historical context.
+     */
+    recommendRelatedHistoricalEntities(entityId, limit, filter) {
+        return this.native
+            .recommendRelatedHistoricalEntities(entityId, limit, filter)
+            .map(normalizeHistoricalEntityRecommendationResult)
+            .filter(Boolean);
+    }
     /**
      * Get the embedding dimension used by the HNSW index.
      * Returns null if vector search is not enabled.
@@ -2299,6 +3373,9 @@ class SocialGraphV2 {
      * Anchors are deduplicated by `(name, anchor_type)`. If an anchor with
      * the same name and type already exists, it is returned (with updated
      * description/overview if changed). Otherwise a new anchor entity is created.
+     * Use `mergeMode: 'soft_merge'` to merge only near-duplicate writes, or
+     * `mergeMode: 'create_distinct'` / `mergeIfExists: false` to always create
+     * a new anchor instance.
      *
      * @param name - Canonical name (e.g., "SocialGraphV2", "RagChat")
      * @param anchorType - Classification: module | concept | api | architecture | feature | library | protocol
@@ -2306,8 +3383,8 @@ class SocialGraphV2 {
      * @param overview - Optional L2 directory-index overview (inspired by OpenViking `.overview.md`)
      * @returns AnchorInfo with id, version, status, overview, etc.
      */
-    anchorUpsert(name, anchorType, description, overview) {
-        return this.native.anchorUpsert(name, anchorType, description, overview ?? undefined);
+    anchorUpsert(name, anchorType, description, overview, options) {
+        return this.native.anchorUpsert(name, anchorType, description, overview ?? undefined, options ?? undefined);
     }
     /**
      * Update only the overview of an existing anchor (by entity ID).