@plur-ai/core 0.2.9 → 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,815 @@
+import { z } from 'zod';
+
+declare const KnowledgeAnchorSchema: z.ZodObject<{
+    path: z.ZodString;
+    relevance: z.ZodDefault<z.ZodEnum<["primary", "supporting", "example"]>>;
+    snippet: z.ZodOptional<z.ZodString>;
+    snippet_extracted_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    relevance: "primary" | "supporting" | "example";
+    snippet?: string | undefined;
+    snippet_extracted_at?: string | undefined;
+}, {
+    path: string;
+    relevance?: "primary" | "supporting" | "example" | undefined;
+    snippet?: string | undefined;
+    snippet_extracted_at?: string | undefined;
+}>;
+declare const AssociationSchema: z.ZodObject<{
+    target_type: z.ZodEnum<["engram", "document"]>;
+    target: z.ZodString;
+    strength: z.ZodNumber;
+    type: z.ZodEnum<["semantic", "temporal", "causal", "co_accessed"]>;
+    updated_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "semantic" | "temporal" | "causal" | "co_accessed";
+    target_type: "engram" | "document";
+    target: string;
+    strength: number;
+    updated_at?: string | undefined;
+}, {
+    type: "semantic" | "temporal" | "causal" | "co_accessed";
+    target_type: "engram" | "document";
+    target: string;
+    strength: number;
+    updated_at?: string | undefined;
+}>;
+declare const EngramSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodDefault<z.ZodNumber>;
+    status: z.ZodEnum<["active", "dormant", "retired", "candidate"]>;
+    consolidated: z.ZodDefault<z.ZodBoolean>;
+    type: z.ZodEnum<["behavioral", "terminological", "procedural", "architectural"]>;
+    scope: z.ZodString;
+    visibility: z.ZodDefault<z.ZodEnum<["private", "public", "template"]>>;
+    statement: z.ZodString;
+    rationale: z.ZodOptional<z.ZodString>;
+    contraindications: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    source: z.ZodOptional<z.ZodString>;
+    source_patterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    derivation_count: z.ZodDefault<z.ZodNumber>;
+    pack: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    abstract: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    derived_from: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    knowledge_type: z.ZodOptional<z.ZodObject<{
+        memory_class: z.ZodEnum<["semantic", "episodic", "procedural", "metacognitive"]>;
+        cognitive_level: z.ZodEnum<["remember", "understand", "apply", "analyze", "evaluate", "create"]>;
+    }, "strip", z.ZodTypeAny, {
+        memory_class: "procedural" | "semantic" | "episodic" | "metacognitive";
+        cognitive_level: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
+    }, {
+        memory_class: "procedural" | "semantic" | "episodic" | "metacognitive";
+        cognitive_level: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
+    }>>;
+    domain: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    activation: z.ZodDefault<z.ZodObject<{
+        retrieval_strength: z.ZodNumber;
+        storage_strength: z.ZodNumber;
+        frequency: z.ZodNumber;
+        last_accessed: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        retrieval_strength: number;
+        storage_strength: number;
+        frequency: number;
+        last_accessed: string;
+    }, {
+        retrieval_strength: number;
+        storage_strength: number;
+        frequency: number;
+        last_accessed: string;
+    }>>;
+    relations: z.ZodOptional<z.ZodObject<{
+        broader: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        narrower: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        related: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        conflicts: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        broader: string[];
+        narrower: string[];
+        related: string[];
+        conflicts: string[];
+    }, {
+        broader?: string[] | undefined;
+        narrower?: string[] | undefined;
+        related?: string[] | undefined;
+        conflicts?: string[] | undefined;
+    }>>;
+    associations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        target_type: z.ZodEnum<["engram", "document"]>;
+        target: z.ZodString;
+        strength: z.ZodNumber;
+        type: z.ZodEnum<["semantic", "temporal", "causal", "co_accessed"]>;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "semantic" | "temporal" | "causal" | "co_accessed";
+        target_type: "engram" | "document";
+        target: string;
+        strength: number;
+        updated_at?: string | undefined;
+    }, {
+        type: "semantic" | "temporal" | "causal" | "co_accessed";
+        target_type: "engram" | "document";
+        target: string;
+        strength: number;
+        updated_at?: string | undefined;
+    }>, "many">>;
+    knowledge_anchors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        relevance: z.ZodDefault<z.ZodEnum<["primary", "supporting", "example"]>>;
+        snippet: z.ZodOptional<z.ZodString>;
+        snippet_extracted_at: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        relevance: "primary" | "supporting" | "example";
+        snippet?: string | undefined;
+        snippet_extracted_at?: string | undefined;
+    }, {
+        path: string;
+        relevance?: "primary" | "supporting" | "example" | undefined;
+        snippet?: string | undefined;
+        snippet_extracted_at?: string | undefined;
+    }>, "many">>;
+    dual_coding: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        example: z.ZodOptional<z.ZodString>;
+        analogy: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        example?: string | undefined;
+        analogy?: string | undefined;
+    }, {
+        example?: string | undefined;
+        analogy?: string | undefined;
+    }>, {
+        example?: string | undefined;
+        analogy?: string | undefined;
+    }, {
+        example?: string | undefined;
+        analogy?: string | undefined;
+    }>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        origin: z.ZodString;
+        chain: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        signature: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        license: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        origin: string;
+        chain: string[];
+        signature: string | null;
+        license: string;
+    }, {
+        origin: string;
+        chain?: string[] | undefined;
+        signature?: string | null | undefined;
+        license?: string | undefined;
+    }>>;
+    feedback_signals: z.ZodDefault<z.ZodObject<{
+        positive: z.ZodDefault<z.ZodNumber>;
+        negative: z.ZodDefault<z.ZodNumber>;
+        neutral: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        positive: number;
+        negative: number;
+        neutral: number;
+    }, {
+        positive?: number | undefined;
+        negative?: number | undefined;
+        neutral?: number | undefined;
+    }>>;
+    /** Typed entity references extracted from statement. Enables graph queries. */
+    entities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["person", "organization", "technology", "concept", "project", "tool", "place", "event", "standard", "other"]>;
+        uri: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "person" | "organization" | "technology" | "concept" | "project" | "tool" | "place" | "event" | "standard" | "other";
+        name: string;
+        uri?: string | undefined;
+    }, {
+        type: "person" | "organization" | "technology" | "concept" | "project" | "tool" | "place" | "event" | "standard" | "other";
+        name: string;
+        uri?: string | undefined;
+    }>, "many">>;
+    /** Temporal validity window. When is this knowledge true? */
+    temporal: z.ZodOptional<z.ZodObject<{
+        learned_at: z.ZodString;
+        valid_from: z.ZodOptional<z.ZodString>;
+        valid_until: z.ZodOptional<z.ZodString>;
+        ingested_at: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        learned_at: string;
+        valid_from?: string | undefined;
+        valid_until?: string | undefined;
+        ingested_at?: string | undefined;
+    }, {
+        learned_at: string;
+        valid_from?: string | undefined;
+        valid_until?: string | undefined;
+        ingested_at?: string | undefined;
+    }>>;
+    /** Automatic usage tracking. Injections, hits, misses. */
+    usage: z.ZodOptional<z.ZodObject<{
+        injections: z.ZodDefault<z.ZodNumber>;
+        hits: z.ZodDefault<z.ZodNumber>;
+        misses: z.ZodDefault<z.ZodNumber>;
+        last_hit_at: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        injections: number;
+        hits: number;
+        misses: number;
+        last_hit_at?: string | undefined;
+    }, {
+        injections?: number | undefined;
+        hits?: number | undefined;
+        misses?: number | undefined;
+        last_hit_at?: string | undefined;
+    }>>;
+    /** Episodic context: emotional weight, confidence, trigger. */
+    episodic: z.ZodOptional<z.ZodObject<{
+        emotional_weight: z.ZodDefault<z.ZodNumber>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        trigger_context: z.ZodOptional<z.ZodString>;
+        journal_ref: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        emotional_weight: number;
+        confidence: number;
+        trigger_context?: string | undefined;
+        journal_ref?: string | undefined;
+    }, {
+        emotional_weight?: number | undefined;
+        confidence?: number | undefined;
+        trigger_context?: string | undefined;
+        journal_ref?: string | undefined;
+    }>>;
+    /** Exchange marketplace metadata: fitness, adoption, diversity. */
+    exchange: z.ZodOptional<z.ZodObject<{
+        fitness_score: z.ZodOptional<z.ZodNumber>;
+        environmental_diversity: z.ZodDefault<z.ZodNumber>;
+        adoption_count: z.ZodDefault<z.ZodNumber>;
+        contradiction_rate: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        environmental_diversity: number;
+        adoption_count: number;
+        contradiction_rate: number;
+        fitness_score?: number | undefined;
+    }, {
+        fitness_score?: number | undefined;
+        environmental_diversity?: number | undefined;
+        adoption_count?: number | undefined;
+        contradiction_rate?: number | undefined;
+    }>>;
+    /** Extensible key-value data for domain-specific fields. */
+    structured_data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "behavioral" | "architectural" | "procedural" | "terminological";
+    status: "active" | "dormant" | "retired" | "candidate";
+    id: string;
+    version: number;
+    consolidated: boolean;
+    scope: string;
+    visibility: "private" | "public" | "template";
+    statement: string;
+    derivation_count: number;
+    pack: string | null;
+    abstract: string | null;
+    derived_from: string | null;
+    tags: string[];
+    activation: {
+        retrieval_strength: number;
+        storage_strength: number;
+        frequency: number;
+        last_accessed: string;
+    };
+    associations: {
+        type: "semantic" | "temporal" | "causal" | "co_accessed";
+        target_type: "engram" | "document";
+        target: string;
+        strength: number;
+        updated_at?: string | undefined;
+    }[];
+    knowledge_anchors: {
+        path: string;
+        relevance: "primary" | "supporting" | "example";
+        snippet?: string | undefined;
+        snippet_extracted_at?: string | undefined;
+    }[];
+    feedback_signals: {
+        positive: number;
+        negative: number;
+        neutral: number;
+    };
+    rationale?: string | undefined;
+    contraindications?: string[] | undefined;
+    source?: string | undefined;
+    source_patterns?: string[] | undefined;
+    episodic?: {
+        emotional_weight: number;
+        confidence: number;
+        trigger_context?: string | undefined;
+        journal_ref?: string | undefined;
+    } | undefined;
+    knowledge_type?: {
+        memory_class: "procedural" | "semantic" | "episodic" | "metacognitive";
+        cognitive_level: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
+    } | undefined;
+    domain?: string | undefined;
+    relations?: {
+        broader: string[];
+        narrower: string[];
+        related: string[];
+        conflicts: string[];
+    } | undefined;
+    temporal?: {
+        learned_at: string;
+        valid_from?: string | undefined;
+        valid_until?: string | undefined;
+        ingested_at?: string | undefined;
+    } | undefined;
+    dual_coding?: {
+        example?: string | undefined;
+        analogy?: string | undefined;
+    } | undefined;
+    provenance?: {
+        origin: string;
+        chain: string[];
+        signature: string | null;
+        license: string;
+    } | undefined;
+    entities?: {
+        type: "person" | "organization" | "technology" | "concept" | "project" | "tool" | "place" | "event" | "standard" | "other";
+        name: string;
+        uri?: string | undefined;
+    }[] | undefined;
+    usage?: {
+        injections: number;
+        hits: number;
+        misses: number;
+        last_hit_at?: string | undefined;
+    } | undefined;
+    exchange?: {
+        environmental_diversity: number;
+        adoption_count: number;
+        contradiction_rate: number;
+        fitness_score?: number | undefined;
+    } | undefined;
+    structured_data?: Record<string, unknown> | undefined;
+}, {
+    type: "behavioral" | "architectural" | "procedural" | "terminological";
+    status: "active" | "dormant" | "retired" | "candidate";
+    id: string;
+    scope: string;
+    statement: string;
+    version?: number | undefined;
+    consolidated?: boolean | undefined;
+    visibility?: "private" | "public" | "template" | undefined;
+    rationale?: string | undefined;
+    contraindications?: string[] | undefined;
+    source?: string | undefined;
+    source_patterns?: string[] | undefined;
+    derivation_count?: number | undefined;
+    pack?: string | null | undefined;
+    abstract?: string | null | undefined;
+    derived_from?: string | null | undefined;
+    episodic?: {
+        emotional_weight?: number | undefined;
+        confidence?: number | undefined;
+        trigger_context?: string | undefined;
+        journal_ref?: string | undefined;
+    } | undefined;
+    knowledge_type?: {
+        memory_class: "procedural" | "semantic" | "episodic" | "metacognitive";
+        cognitive_level: "remember" | "understand" | "apply" | "analyze" | "evaluate" | "create";
+    } | undefined;
+    domain?: string | undefined;
+    tags?: string[] | undefined;
+    activation?: {
+        retrieval_strength: number;
+        storage_strength: number;
+        frequency: number;
+        last_accessed: string;
+    } | undefined;
+    relations?: {
+        broader?: string[] | undefined;
+        narrower?: string[] | undefined;
+        related?: string[] | undefined;
+        conflicts?: string[] | undefined;
+    } | undefined;
+    temporal?: {
+        learned_at: string;
+        valid_from?: string | undefined;
+        valid_until?: string | undefined;
+        ingested_at?: string | undefined;
+    } | undefined;
+    associations?: {
+        type: "semantic" | "temporal" | "causal" | "co_accessed";
+        target_type: "engram" | "document";
+        target: string;
+        strength: number;
+        updated_at?: string | undefined;
+    }[] | undefined;
+    knowledge_anchors?: {
+        path: string;
+        relevance?: "primary" | "supporting" | "example" | undefined;
+        snippet?: string | undefined;
+        snippet_extracted_at?: string | undefined;
+    }[] | undefined;
+    dual_coding?: {
+        example?: string | undefined;
+        analogy?: string | undefined;
+    } | undefined;
+    provenance?: {
+        origin: string;
+        chain?: string[] | undefined;
+        signature?: string | null | undefined;
+        license?: string | undefined;
+    } | undefined;
+    feedback_signals?: {
+        positive?: number | undefined;
+        negative?: number | undefined;
+        neutral?: number | undefined;
+    } | undefined;
+    entities?: {
+        type: "person" | "organization" | "technology" | "concept" | "project" | "tool" | "place" | "event" | "standard" | "other";
+        name: string;
+        uri?: string | undefined;
+    }[] | undefined;
+    usage?: {
+        injections?: number | undefined;
+        hits?: number | undefined;
+        misses?: number | undefined;
+        last_hit_at?: string | undefined;
+    } | undefined;
+    exchange?: {
+        fitness_score?: number | undefined;
+        environmental_diversity?: number | undefined;
+        adoption_count?: number | undefined;
+        contradiction_rate?: number | undefined;
+    } | undefined;
+    structured_data?: Record<string, unknown> | undefined;
+}>;
+type Engram = z.infer<typeof EngramSchema>;
+type KnowledgeAnchor = z.infer<typeof KnowledgeAnchorSchema>;
+type Association = z.infer<typeof AssociationSchema>;
+
+declare const PackManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    creator: z.ZodOptional<z.ZodString>;
+    license: z.ZodDefault<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        injection_policy: z.ZodDefault<z.ZodEnum<["on_match", "on_request", "always"]>>;
+        match_terms: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        domain: z.ZodOptional<z.ZodString>;
+        engram_count: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        injection_policy: "on_match" | "on_request" | "always";
+        match_terms: string[];
+        id?: string | undefined;
+        domain?: string | undefined;
+        engram_count?: number | undefined;
+    }, {
+        id?: string | undefined;
+        domain?: string | undefined;
+        injection_policy?: "on_match" | "on_request" | "always" | undefined;
+        match_terms?: string[] | undefined;
+        engram_count?: number | undefined;
+    }>>;
+    'x-datacore': z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        injection_policy: z.ZodEnum<["on_match", "on_request"]>;
+        match_terms: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        domain: z.ZodOptional<z.ZodString>;
+        engram_count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        injection_policy: "on_match" | "on_request";
+        match_terms: string[];
+        engram_count: number;
+        domain?: string | undefined;
+    }, {
+        id: string;
+        injection_policy: "on_match" | "on_request";
+        engram_count: number;
+        domain?: string | undefined;
+        match_terms?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    tags: string[];
+    license: string;
+    name: string;
+    description?: string | undefined;
+    creator?: string | undefined;
+    metadata?: {
+        injection_policy: "on_match" | "on_request" | "always";
+        match_terms: string[];
+        id?: string | undefined;
+        domain?: string | undefined;
+        engram_count?: number | undefined;
+    } | undefined;
+    'x-datacore'?: {
+        id: string;
+        injection_policy: "on_match" | "on_request";
+        match_terms: string[];
+        engram_count: number;
+        domain?: string | undefined;
+    } | undefined;
+}, {
+    version: string;
+    name: string;
+    tags?: string[] | undefined;
+    license?: string | undefined;
+    description?: string | undefined;
+    creator?: string | undefined;
+    metadata?: {
+        id?: string | undefined;
+        domain?: string | undefined;
+        injection_policy?: "on_match" | "on_request" | "always" | undefined;
+        match_terms?: string[] | undefined;
+        engram_count?: number | undefined;
+    } | undefined;
+    'x-datacore'?: {
+        id: string;
+        injection_policy: "on_match" | "on_request";
+        engram_count: number;
+        domain?: string | undefined;
+        match_terms?: string[] | undefined;
+    } | undefined;
+}>;
+type PackManifest = z.infer<typeof PackManifestSchema>;
+
+interface PackInfo {
+    name: string;
+    path: string;
+    engram_count: number;
+    manifest?: PackManifest;
+}
+declare function listPacks(packsDir: string): PackInfo[];
+
+interface SyncStatus {
+    initialized: boolean;
+    remote: string | null;
+    dirty: boolean;
+    branch: string | null;
+    ahead: number;
+    behind: number;
+}
+interface SyncResult {
+    action: 'initialized' | 'committed' | 'synced' | 'up-to-date';
+    message: string;
+    remote: string | null;
+    files_changed: number;
+}
+
+declare const EpisodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    summary: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    summary: string;
+    timestamp: string;
+    tags?: string[] | undefined;
+    agent?: string | undefined;
+    channel?: string | undefined;
+    session_id?: string | undefined;
+}, {
+    id: string;
+    summary: string;
+    timestamp: string;
+    tags?: string[] | undefined;
+    agent?: string | undefined;
+    channel?: string | undefined;
+    session_id?: string | undefined;
+}>;
+type Episode = z.infer<typeof EpisodeSchema>;
+
+declare const PlurConfigSchema: z.ZodObject<{
+    auto_learn: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    auto_capture: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    injection_budget: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    decay_enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    decay_threshold: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    packs: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    injection: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        spread_cap: z.ZodDefault<z.ZodNumber>;
+        spread_budget: z.ZodDefault<z.ZodNumber>;
+        co_access: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        spread_cap: number;
+        spread_budget: number;
+        co_access: boolean;
+    }, {
+        spread_cap?: number | undefined;
+        spread_budget?: number | undefined;
+        co_access?: boolean | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    auto_learn?: boolean | undefined;
+    auto_capture?: boolean | undefined;
+    injection_budget?: number | undefined;
+    decay_enabled?: boolean | undefined;
+    decay_threshold?: number | undefined;
+    packs?: string[] | undefined;
+    injection?: {
+        spread_cap: number;
+        spread_budget: number;
+        co_access: boolean;
+    } | undefined;
+}, {
+    auto_learn?: boolean | undefined;
+    auto_capture?: boolean | undefined;
+    injection_budget?: number | undefined;
+    decay_enabled?: boolean | undefined;
+    decay_threshold?: number | undefined;
+    packs?: string[] | undefined;
+    injection?: {
+        spread_cap?: number | undefined;
+        spread_budget?: number | undefined;
+        co_access?: boolean | undefined;
+    } | undefined;
+}>;
+type PlurConfig = z.infer<typeof PlurConfigSchema>;
+
+interface LearnContext {
+    type?: 'behavioral' | 'terminological' | 'procedural' | 'architectural';
+    scope?: string;
+    domain?: string;
+    source?: string;
+}
+/**
+ * Function that calls an LLM. Model-agnostic — consumer provides this.
+ * Takes a prompt, returns the LLM's text response.
+ */
+type LlmFunction = (prompt: string) => Promise<string>;
+interface RecallOptions {
+    scope?: string;
+    domain?: string;
+    limit?: number;
+    min_strength?: number;
+    /** Search mode: 'fast' (BM25, default) or 'agentic' (LLM-assisted semantic search) */
+    mode?: 'fast' | 'agentic';
+    /** LLM function for agentic mode. Required when mode='agentic'. */
+    llm?: LlmFunction;
+}
+interface InjectOptions {
+    budget?: number;
+    scope?: string;
+    boost_recent?: boolean;
+}
+interface InjectionResult {
+    directives: string;
+    consider: string;
+    count: number;
+    tokens_used: number;
+}
+interface CaptureContext {
+    agent?: string;
+    channel?: string;
+    session_id?: string;
+    tags?: string[];
+}
+interface TimelineQuery {
+    since?: Date;
+    until?: Date;
+    agent?: string;
+    channel?: string;
+    search?: string;
+}
+
+/** Build searchable text from all engram fields */
+declare function engramSearchText(engram: Engram): string;
+
+interface PlurPaths {
+    root: string;
+    engrams: string;
+    episodes: string;
+    candidates: string;
+    packs: string;
+    exchange: string;
+    config: string;
+}
+declare function detectPlurStorage(explicitPath?: string): PlurPaths;
+
+/**
+ * Non-blocking version check against npm registry.
+ * Caches result in memory — one fetch per process lifetime.
+ * Never throws or blocks startup.
+ */
+interface VersionCheckResult {
+    current: string;
+    latest: string | null;
+    updateAvailable: boolean;
+    checkedAt: number | null;
+}
+/**
+ * Check npm for a newer version. Fetches once, caches forever (process lifetime).
+ * Fire-and-forget: call at startup, read later via getCachedUpdateCheck().
+ */
+declare function checkForUpdate(packageName: string, currentVersion: string, onResult?: (result: VersionCheckResult) => void): Promise<VersionCheckResult>;
+/**
+ * Read the cached version check result. Returns null if checkForUpdate() hasn't
+ * completed yet. This is the zero-cost read path for assemblers.
+ */
+declare function getCachedUpdateCheck(packageName: string): VersionCheckResult | null;
+/** Clear cache (for testing). */
+declare function clearVersionCache(): void;
+
+interface IngestOptions {
+    source?: string;
+    extract_only?: boolean;
+    scope?: string;
+    domain?: string;
+}
+interface IngestCandidate {
+    statement: string;
+    type: 'behavioral' | 'architectural' | 'procedural';
+    source?: string;
+}
+interface StatusResult {
+    engram_count: number;
+    episode_count: number;
+    pack_count: number;
+    storage_root: string;
+    config: PlurConfig;
+}
+declare class Plur {
+    private paths;
+    private config;
+    constructor(options?: {
+        path?: string;
+    });
+    /** Create engram, detect conflicts, save. Returns the created engram. */
+    learn(statement: string, context?: LearnContext): Engram;
+    /**
+     * Search engrams, filter by scope/domain/strength, reactivate accessed.
+     * Supports two modes:
+     *   - 'fast' (default): BM25 keyword search, instant, no API calls
+     *   - 'agentic': LLM-assisted semantic search, higher accuracy, requires llm function
+     */
+    /** Search engrams using fast BM25 keyword matching. Sync, no API calls. */
+    recall(query: string, options?: Omit<RecallOptions, 'mode' | 'llm'>): Engram[];
+    /** Search engrams using LLM-assisted semantic filtering. Async, requires llm function. */
+    recallAsync(query: string, options: RecallOptions & {
+        llm: LlmFunction;
+    }): Promise<Engram[]>;
+    /** Search engrams using local embeddings (transformers.js). Async, no API calls. */
+    recallSemantic(query: string, options?: Omit<RecallOptions, 'mode' | 'llm'>): Promise<Engram[]>;
+    /** Hybrid search: BM25 + embeddings merged via Reciprocal Rank Fusion. Async, no API calls. */
+    recallHybrid(query: string, options?: Omit<RecallOptions, 'mode' | 'llm'>): Promise<Engram[]>;
+    /** Expanded search: LLM query expansion + hybrid search + RRF merge. Opt-in, requires LLM function. */
+    recallExpanded(query: string, options: RecallOptions & {
+        llm: LlmFunction;
+    }): Promise<Engram[]>;
+    /** Filter engrams by scope/domain/strength (shared by both modes) */
+    private _filterEngrams;
+    /** Reactivate accessed engrams (bump retrieval strength, frequency, last_accessed) */
+    private _reactivateResults;
+    /** Scored injection within token budget (BM25 only). Returns formatted strings. */
+    inject(task: string, options?: InjectOptions): InjectionResult;
+    /** Scored injection with embedding boost when available. Falls back to BM25 if embeddings not installed. */
+    injectHybrid(task: string, options?: InjectOptions): Promise<InjectionResult>;
+    private _formatInjection;
+    /** Update feedback_signals and adjust retrieval_strength. */
+    feedback(id: string, signal: 'positive' | 'negative' | 'neutral'): void;
+    /** Set engram status to 'retired'. */
+    forget(id: string, reason?: string): void;
+    /** Capture an episodic memory. */
+    capture(summary: string, context?: CaptureContext): Episode;
+    /** Query the episode timeline. */
+    timeline(query?: TimelineQuery): Episode[];
+    /** Rule-based extraction of engram candidates from content. */
+    ingest(content: string, options?: IngestOptions): IngestCandidate[];
+    /** Install a pack from a source path. */
+    installPack(source: string): {
+        installed: number;
+        name: string;
+    };
+    /** Export engrams as a shareable pack. */
+    exportPack(engrams: Engram[], outputDir: string, manifest: {
+        name: string;
+        version: string;
+        description?: string;
+        creator?: string;
+    }): {
+        path: string;
+        engram_count: number;
+    };
+    /** List all installed packs. */
+    listPacks(): ReturnType<typeof listPacks>;
+    /** Sync engrams to git. Initializes repo on first call, commits + push/pull on subsequent calls. */
+    sync(remote?: string): SyncResult;
+    /** Get git sync status without making changes. */
+    syncStatus(): SyncStatus;
+    /** Return system health info. */
+    status(): StatusResult;
+}
+
+export { type Association, type CaptureContext, type Engram, type Episode, type IngestCandidate, type IngestOptions, type InjectOptions, type InjectionResult, type KnowledgeAnchor, type LearnContext, type LlmFunction, type PackManifest, Plur, type PlurConfig, type PlurPaths, type RecallOptions, type StatusResult, type SyncResult, type SyncStatus, type TimelineQuery, type VersionCheckResult, checkForUpdate, clearVersionCache, detectPlurStorage, engramSearchText, getCachedUpdateCheck };

package/dist/index.js

@@ -158,6 +158,7 @@ var EngramSchema = z2.object({
   rationale: z2.string().optional(),
   contraindications: z2.array(z2.string()).optional(),
   // Lineage
+  source: z2.string().optional(),
   source_patterns: z2.array(z2.string()).optional(),
   derivation_count: z2.number().int().min(0).default(1),
   pack: z2.string().nullable().default(null),
@@ -242,6 +243,168 @@ var logger = {
   }
 };
 
+// src/sync.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync3, writeFileSync, renameSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2, dirname } from "path";
+var GITIGNORE = `# PLUR \u2014 derived/cache files (regenerated automatically)
+embeddings/
+.embeddings-cache.json
+*.db
+*.sqlite
+exchange/
+`;
+function git(args, cwd) {
+  return execFileSync("git", args, { cwd, encoding: "utf8", timeout: 3e4 }).trim();
+}
+function gitSafe(args, cwd) {
+  try {
+    return git(args, cwd);
+  } catch {
+    return null;
+  }
+}
+function isGitRepo(root) {
+  return existsSync3(join2(root, ".git"));
+}
+function hasGitCli() {
+  try {
+    execFileSync("git", ["--version"], { encoding: "utf8", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getRemote(root) {
+  return gitSafe(["remote", "get-url", "origin"], root);
+}
+function isDirty(root) {
+  const status = gitSafe(["status", "--porcelain"], root);
+  return status !== null && status.length > 0;
+}
+function countDiff(root, direction) {
+  const tracking = gitSafe(["rev-parse", "--abbrev-ref", "@{u}"], root);
+  if (!tracking) return 0;
+  const flag = direction === "ahead" ? "--left-only" : "--right-only";
+  const count = gitSafe(["rev-list", flag, "--count", "HEAD...@{u}"], root);
+  return count ? parseInt(count, 10) : 0;
+}
+function getSyncStatus(root) {
+  if (!isGitRepo(root)) {
+    return { initialized: false, remote: null, dirty: false, branch: null, ahead: 0, behind: 0 };
+  }
+  const branch = gitSafe(["rev-parse", "--abbrev-ref", "HEAD"], root);
+  const remote = getRemote(root);
+  if (remote) gitSafe(["fetch", "origin", "--quiet"], root);
+  return {
+    initialized: true,
+    remote,
+    dirty: isDirty(root),
+    branch,
+    ahead: countDiff(root, "ahead"),
+    behind: countDiff(root, "behind")
+  };
+}
+function initRepo(root) {
+  git(["init"], root);
+  atomicWrite(join2(root, ".gitignore"), GITIGNORE);
+  git(["add", "-A"], root);
+  git(["commit", "-m", "Initial PLUR engram store"], root);
+}
+function commitChanges(root) {
+  if (!isDirty(root)) return 0;
+  git(["add", "-A"], root);
+  const diff = gitSafe(["diff", "--cached", "--stat", "--shortstat"], root);
+  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
+  git(["commit", "-m", `plur sync ${now}`], root);
+  const match = diff?.match(/(\d+) file/);
+  return match ? parseInt(match[1], 10) : 1;
+}
+function hasConflictMarkers(root) {
+  const result = gitSafe(["grep", "-l", "<<<<<<<"], root);
+  return result !== null && result.length > 0;
+}
+function pullRebase(root) {
+  const result = gitSafe(["pull", "--rebase", "origin", "main"], root);
+  if (result !== null) return true;
+  gitSafe(["rebase", "--abort"], root);
+  const mergeResult = gitSafe(["pull", "origin", "main", "--no-edit"], root);
+  if (mergeResult !== null) return true;
+  if (hasConflictMarkers(root)) {
+    gitSafe(["merge", "--abort"], root);
+    throw new Error("Sync conflict: YAML files have merge conflicts that require manual resolution. Your local changes are preserved.");
+  }
+  git(["add", "-A"], root);
+  gitSafe(["commit", "-m", "plur sync: merge conflict resolved (kept both)"], root);
+  return true;
+}
+function sync(root, remote) {
+  if (!hasGitCli()) {
+    throw new Error("git is not installed. Install git to enable sync.");
+  }
+  if (!isGitRepo(root)) {
+    initRepo(root);
+    if (remote) {
+      git(["remote", "add", "origin", remote], root);
+      const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], root);
+      git(["push", "-u", "origin", branch], root);
+      return { action: "initialized", message: `Initialized and pushed to ${remote}`, remote, files_changed: 0 };
+    }
+    return {
+      action: "initialized",
+      message: "Initialized local git repo. Call plur.sync with remote to enable cross-device sync.",
+      remote: null,
+      files_changed: 0
+    };
+  }
+  const existingRemote = getRemote(root);
+  if (remote && !existingRemote) {
+    git(["remote", "add", "origin", remote], root);
+    const filesChanged2 = commitChanges(root);
+    const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], root);
+    git(["push", "-u", "origin", branch], root);
+    return { action: "synced", message: `Remote added and pushed to ${remote}`, remote, files_changed: filesChanged2 };
+  }
+  if (!existingRemote) {
+    const filesChanged2 = commitChanges(root);
+    if (filesChanged2 === 0) {
+      return { action: "up-to-date", message: 'No changes to commit. Add a remote with plur.sync({ remote: "..." }) to enable cross-device sync.', remote: null, files_changed: 0 };
+    }
+    return { action: "committed", message: `Committed ${filesChanged2} file(s) locally.`, remote: null, files_changed: filesChanged2 };
+  }
+  const filesChanged = commitChanges(root);
+  gitSafe(["fetch", "origin", "--quiet"], root);
+  const behind = countDiff(root, "behind");
+  const aheadBefore = countDiff(root, "ahead");
+  if (behind > 0) {
+    pullRebase(root);
+  }
+  const aheadAfter = countDiff(root, "ahead");
+  if (aheadAfter > 0) {
+    gitSafe(["push", "origin"], root);
+  }
+  if (filesChanged === 0 && behind === 0 && aheadBefore === 0) {
+    return { action: "up-to-date", message: "Already in sync.", remote: existingRemote, files_changed: 0 };
+  }
+  const parts = [];
+  if (filesChanged > 0) parts.push(`${filesChanged} file(s) committed`);
+  if (behind > 0) parts.push(`pulled ${behind} remote commit(s)`);
+  if (aheadAfter === 0 && aheadBefore > 0) parts.push("pushed");
+  return {
+    action: "synced",
+    message: `Synced. ${parts.join(", ")}.`,
+    remote: existingRemote,
+    files_changed: filesChanged
+  };
+}
+function atomicWrite(filePath, content) {
+  const dir = dirname(filePath);
+  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
+  const tmp = filePath + ".tmp";
+  writeFileSync(tmp, content);
+  renameSync(tmp, filePath);
+}
+
 // src/engrams.ts
 function loadEngrams(filePath) {
   if (!fs.existsSync(filePath)) return [];
@@ -264,7 +427,7 @@ function loadEngrams(filePath) {
 }
 function saveEngrams(filePath, engrams) {
   const content = yaml2.dump({ engrams }, { lineWidth: 120, noRefs: true, quotingType: '"' });
-  fs.writeFileSync(filePath, content);
+  atomicWrite(filePath, content);
 }
 function parseSkillMdFrontmatter(filePath) {
   const content = fs.readFileSync(filePath, "utf8");
@@ -635,7 +798,7 @@ function selectAndSpread(ctx, personalEngrams, packs, config, embeddingBoosts) {
 }
 
 // src/episodes.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
 import yaml3 from "js-yaml";
 function generateEpisodeId() {
   const ts = Date.now();
@@ -654,7 +817,7 @@ function captureEpisode(path2, summary, context) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
   episodes.push(episode);
-  writeFileSync2(path2, yaml3.dump(episodes, { lineWidth: 120, noRefs: true }), "utf8");
+  atomicWrite(path2, yaml3.dump(episodes, { lineWidth: 120, noRefs: true }));
   return episode;
 }
 function queryTimeline(path2, query) {
@@ -670,7 +833,7 @@ function queryTimeline(path2, query) {
   return episodes;
 }
 function loadEpisodes(path2) {
-  if (!existsSync4(path2)) return [];
+  if (!existsSync5(path2)) return [];
   try {
     const raw = yaml3.load(readFileSync3(path2, "utf8"));
     return Array.isArray(raw) ? raw : [];
@@ -743,8 +906,9 @@ Rules:
 }
 
 // src/embeddings.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3 } from "path";
+import { createHash } from "crypto";
 var embedPipeline = null;
 var transformersUnavailable = false;
 async function getEmbedder() {
@@ -774,7 +938,7 @@ function cosineSimilarity(a, b) {
   return dot;
 }
 function loadCache(cachePath) {
-  if (!existsSync5(cachePath)) return {};
+  if (!existsSync6(cachePath)) return {};
   try {
     return JSON.parse(readFileSync4(cachePath, "utf8"));
   } catch {
@@ -783,19 +947,15 @@ function loadCache(cachePath) {
 }
 function saveCache(cachePath, cache2) {
   const dir = cachePath.substring(0, cachePath.lastIndexOf("/"));
-  if (!existsSync5(dir)) mkdirSync2(dir, { recursive: true });
-  writeFileSync3(cachePath, JSON.stringify(cache2));
+  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
+  atomicWrite(cachePath, JSON.stringify(cache2));
 }
 function hashStatement(statement) {
-  let hash = 0;
-  for (let i = 0; i < statement.length; i++) {
-    hash = (hash << 5) - hash + statement.charCodeAt(i) | 0;
-  }
-  return hash.toString(36);
+  return createHash("sha256").update(statement).digest("hex").slice(0, 16);
 }
 async function embeddingSearch(engrams, query, limit, storagePath) {
   if (engrams.length === 0) return [];
-  const cachePath = storagePath ? join2(storagePath, ".embeddings-cache.json") : ".embeddings-cache.json";
+  const cachePath = storagePath ? join3(storagePath, ".embeddings-cache.json") : ".embeddings-cache.json";
   const cache2 = loadCache(cachePath);
   const queryEmbedding = await embed(query);
   if (!queryEmbedding) {
@@ -1023,152 +1183,6 @@ ${manifest.description || ""}
   return { path: outputDir, engram_count: engrams.length };
 }
 
-// src/sync.ts
-import { execSync } from "child_process";
-import { existsSync as existsSync7, writeFileSync as writeFileSync5 } from "fs";
-import { join as join4 } from "path";
-var GITIGNORE = `# PLUR \u2014 derived/cache files (regenerated automatically)
-embeddings/
-*.db
-*.sqlite
-exchange/
-`;
-function git(args, cwd) {
-  return execSync(`git ${args}`, { cwd, encoding: "utf8", timeout: 3e4 }).trim();
-}
-function gitSafe(args, cwd) {
-  try {
-    return git(args, cwd);
-  } catch {
-    return null;
-  }
-}
-function isGitRepo(root) {
-  return existsSync7(join4(root, ".git"));
-}
-function hasGitCli() {
-  try {
-    execSync("git --version", { encoding: "utf8", timeout: 5e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getRemote(root) {
-  return gitSafe("remote get-url origin", root);
-}
-function isDirty(root) {
-  const status = gitSafe("status --porcelain", root);
-  return status !== null && status.length > 0;
-}
-function countDiff(root, direction) {
-  const tracking = gitSafe("rev-parse --abbrev-ref @{u}", root);
-  if (!tracking) return 0;
-  const flag = direction === "ahead" ? "left" : "right";
-  const count = gitSafe(`rev-list --${flag}-only --count HEAD...@{u}`, root);
-  return count ? parseInt(count, 10) : 0;
-}
-function getSyncStatus(root) {
-  if (!isGitRepo(root)) {
-    return { initialized: false, remote: null, dirty: false, branch: null, ahead: 0, behind: 0 };
-  }
-  const branch = gitSafe("rev-parse --abbrev-ref HEAD", root);
-  const remote = getRemote(root);
-  if (remote) gitSafe("fetch origin --quiet", root);
-  return {
-    initialized: true,
-    remote,
-    dirty: isDirty(root),
-    branch,
-    ahead: countDiff(root, "ahead"),
-    behind: countDiff(root, "behind")
-  };
-}
-function initRepo(root) {
-  git("init", root);
-  writeFileSync5(join4(root, ".gitignore"), GITIGNORE);
-  git("add -A", root);
-  git('commit -m "Initial PLUR engram store"', root);
-}
-function commitChanges(root) {
-  if (!isDirty(root)) return 0;
-  git("add -A", root);
-  const diff = gitSafe("diff --cached --stat --shortstat", root);
-  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
-  git(`commit -m "plur sync ${now}"`, root);
-  const match = diff?.match(/(\d+) file/);
-  return match ? parseInt(match[1], 10) : 1;
-}
-function pullRebase(root) {
-  const result = gitSafe("pull --rebase origin main", root);
-  if (result !== null) return true;
-  gitSafe("rebase --abort", root);
-  const mergeResult = gitSafe("pull origin main --no-edit", root);
-  if (mergeResult !== null) return true;
-  git("add -A", root);
-  gitSafe('commit -m "plur sync: merge conflict resolved (kept both)"', root);
-  return true;
-}
-function sync(root, remote) {
-  if (!hasGitCli()) {
-    throw new Error("git is not installed. Install git to enable sync.");
-  }
-  if (!isGitRepo(root)) {
-    initRepo(root);
-    if (remote) {
-      git(`remote add origin ${remote}`, root);
-      const branch = git("rev-parse --abbrev-ref HEAD", root);
-      git(`push -u origin ${branch}`, root);
-      return { action: "initialized", message: `Initialized and pushed to ${remote}`, remote, files_changed: 0 };
-    }
-    return {
-      action: "initialized",
-      message: "Initialized local git repo. Call plur.sync with remote to enable cross-device sync.",
-      remote: null,
-      files_changed: 0
-    };
-  }
-  const existingRemote = getRemote(root);
-  if (remote && !existingRemote) {
-    git(`remote add origin ${remote}`, root);
-    const filesChanged2 = commitChanges(root);
-    const branch = git("rev-parse --abbrev-ref HEAD", root);
-    git(`push -u origin ${branch}`, root);
-    return { action: "synced", message: `Remote added and pushed to ${remote}`, remote, files_changed: filesChanged2 };
-  }
-  if (!existingRemote) {
-    const filesChanged2 = commitChanges(root);
-    if (filesChanged2 === 0) {
-      return { action: "up-to-date", message: 'No changes to commit. Add a remote with plur.sync({ remote: "..." }) to enable cross-device sync.', remote: null, files_changed: 0 };
-    }
-    return { action: "committed", message: `Committed ${filesChanged2} file(s) locally.`, remote: null, files_changed: filesChanged2 };
-  }
-  const filesChanged = commitChanges(root);
-  gitSafe("fetch origin --quiet", root);
-  const behind = countDiff(root, "behind");
-  const aheadBefore = countDiff(root, "ahead");
-  if (behind > 0) {
-    pullRebase(root);
-  }
-  const aheadAfter = countDiff(root, "ahead");
-  if (aheadAfter > 0) {
-    gitSafe("push origin", root);
-  }
-  if (filesChanged === 0 && behind === 0 && aheadBefore === 0) {
-    return { action: "up-to-date", message: "Already in sync.", remote: existingRemote, files_changed: 0 };
-  }
-  const parts = [];
-  if (filesChanged > 0) parts.push(`${filesChanged} file(s) committed`);
-  if (behind > 0) parts.push(`pulled ${behind} remote commit(s)`);
-  if (aheadAfter === 0 && aheadBefore > 0) parts.push("pushed");
-  return {
-    action: "synced",
-    message: `Synced. ${parts.join(", ")}.`,
-    remote: existingRemote,
-    files_changed: filesChanged
-  };
-}
-
 // src/version-check.ts
 var cache = /* @__PURE__ */ new Map();
 async function checkForUpdate(packageName, currentVersion, onResult) {
@@ -1252,6 +1266,7 @@ var Plur = class {
       scope,
       visibility: "private",
       statement,
+      source: context?.source,
       domain: context?.domain,
       activation: {
         retrieval_strength: 0.7,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plur-ai/core",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,9 +38,8 @@
   "author": "PLUR <info@plur.ai>",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
   "scripts": {