crbro-memory 2.10.0 → 2.11.0

package/dist/engine/cortex.d.ts

@@ -1,682 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { type Op } from '../sync/ops.js';
-import { type MergeReport } from '../sync/materialize.js';
-import { type ShelfReason } from './shelf.js';
-import { type VerificationInput } from './evidence.js';
-import type { Brain } from './brain.js';
-import type { Neuron, NeuronType, Fact, FactStatus, ShelfLife, SourceReference, Verification } from '../types/index.js';
-/**
- * `witnessed`: "<neuron>|<fact id>" of every fact this session stored or
- * confirmed. A session is one witness: storing the same line again in the
- * same session (a retry, the post-compaction re-save) does not count twice.
- * Not cleared by consolidate, which ends a chapter, not the conversation.
- */
-export interface SessionTally {
-    facts: number;
-    decisions: number;
-    topics: Set<string>;
-    witnessed?: Set<string>;
-    verifiedEmitted?: Set<string>;
-}
-export declare const newTally: () => SessionTally;
-/**
- * The connection a request belongs to, carried through every await. Empty
- * outside the daemon. `resumed`: this backend took over a conversation that
- * was already running (its daemon died), so the tally starts at zero although
- * the conversation did not — consolidate must not present that zero as the truth.
- */
-export declare const sessionScope: AsyncLocalStorage<{
-    tally: SessionTally;
-    resumed?: boolean;
-}>;
-/**
- * Near-duplicates of `content` among `candidates`, best first: Dice ≥ 0.8 on
- * lower-cased text, both sides at least NEAR_DUP_MIN_LENGTH characters. The
- * one rule behind learn's near_duplicates warning (inside one neuron) and
- * consolidate's promotion_candidates (across project neurons), so the two
- * cannot disagree on what "almost the same line" means.
- */
-export declare function nearDuplicatesAmong(content: string, candidates: Array<{
-    id: string;
-    text: string;
-}>): Array<{
-    id: string;
-    similarity: number;
-    text: string;
-}>;
-/** Lesson kinds that can be promoted: what was learned, not what was decided or preferred. */
-export type LessonKind = 'fact' | 'pattern' | 'error';
-export interface PromotionCandidate {
-    kind: LessonKind;
-    /** The telling to promote: the most confirmed copy, then the longest. */
-    text: string;
-    /** Project neurons that hold it, the one written this session first. */
-    neurons: string[];
-    /** The entry id of the copy in each of `neurons`, same order. */
-    entry_ids: string[];
-    /** Lowest similarity in the group: 1 when every copy is the same text. */
-    similarity: number;
-    /** Sum of the copies' confirmations (each copy counts at least 1). */
-    confirmations: number;
-}
-/** Most promotion candidates consolidate reports. More is a backlog, not a nudge. */
-export declare const MAX_PROMOTION_CANDIDATES = 5;
-/**
- * The same lesson living in two or more project neurons: the mark of
- * something that is not about one project at all and belongs in a tech_ or
- * process_ neuron where every project finds it.
- *
- * Generalises findNearDuplicates (one neuron) to many without making it
- * quadratic: only the lessons of `seedIds` — the project neurons this session
- * touched — are compared, and each only against the lessons that hold the
- * same numbers and most of its distinctive words (inverted indexes built
- * once). The bigram test then decides, as in learn. Exact copies (same
- * normalised text) count at any length.
- *
- * Only the user's own lessons take part. A line that arrived from a shared
- * space, the miner or anything that is not this machine's session is left
- * out: promoting it would rewrite a third party's text as the user's own
- * lesson, valid for every project, and drop the origin recall shows for it.
- *
- * Read-only and pure: it suggests, it never moves anything.
- */
-export declare function findPromotionCandidates(neurons: Neuron[], seedIds: Iterable<string>, max?: number): PromotionCandidate[];
-export type Indexer = (neuron: Neuron) => Promise<void> | void;
-/**
- * Called after a write so shared neurons can append a note to the team log.
- * A hook rather than a direct call, because the sync layer needs the Cortex
- * and the Cortex would then need the sync layer.
- */
-export type Emitter = (neuronId: string, change: {
-    kind: 'fact';
-    text: string;
-    fid: string;
-    conf: number;
-    at: string;
-    src?: string;
-    keys?: string[];
-    shelf?: ShelfLife;
-    reference?: SourceReference;
-    temporal?: Fact['temporal'];
-    verification_invalidated_at?: string;
-} | {
-    kind: 'status';
-    fid: string;
-    to: 'superseded' | 'retracted';
-    at: string;
-    why?: string;
-} | {
-    kind: 'decision';
-    text: string;
-    why?: string;
-    at: string;
-} | {
-    kind: 'pattern';
-    text: string;
-    at: string;
-} | {
-    kind: 'error';
-    text: string;
-    at: string;
-} | {
-    kind: 'debt';
-    text: string;
-    at: string;
-} | {
-    kind: 'map';
-    text: string;
-    at: string;
-} | {
-    kind: 'error_purge';
-    key: string;
-    at: string;
-} | {
-    kind: 'debt_purge';
-    key: string;
-    at: string;
-} | {
-    kind: 'decision_purge';
-    key: string;
-    at: string;
-} | {
-    kind: 'pattern_purge';
-    key: string;
-    at: string;
-}
-/** A line was checked against its source and still holds (shelf life). `at` is the check. */
- | {
-    kind: 'verify';
-    eid: string;
-    ekind: 'fact' | 'entry';
-    at: string;
-    verification?: Verification;
-}) => Promise<void> | void;
-/**
- * Called after a neuron file is deleted, so the search index drops its
- * chunks. The mirror of Indexer: without it a forgotten neuron kept
- * answering recall until the next full rebuild.
- */
-export type Remover = (neuronId: string) => Promise<void> | void;
-/**
- * Everything of `source` folded into `target`, as a new object.
- *
- * Shared by restoreNeuron (a quarantine copy back over a neuron that was
- * re-created since) and mergeNeurons (two neurons that turned out to be one
- * topic). Pure on purpose: neither input is touched, so the caller can diff
- * the result against what it had and emit only what actually moved.
- *
- * Facts line up by id (the content hash), falling back to normalised text;
- * on a collision the target's telling stays but takes the furthest-along
- * status (active < superseded < retracted) and the earliest `added`, and the
- * keys are unioned. Everything else is a set union keyed by normalised text
- * with the target's order first. Local observations (heat, access_count)
- * combine as max and sum; identity (id, name, domain, type) is the target's.
- */
-export declare function unionNeuron(target: Neuron, source: Neuron): {
-    neuron: Neuron;
-    moved: {
-        facts: number;
-        decisions: number;
-        patterns: number;
-        preferences: number;
-        errors: number;
-        debts: number;
-        tags: number;
-        map: 0 | 1;
-    };
-};
-/**
- * Aliases a future question may use, as stored: trimmed, lower-cased, at
- * most 40 characters each, unique, at most eight. Order is kept.
- */
-export declare function normalizeKeys(keys?: string[]): string[];
-export declare class Cortex {
-    private brain;
-    /**
-     * Optional hook invoked after every write. Wiring it here — rather than
-     * calling the search engine from each caller — is what guarantees the miner
-     * path gets indexed too. Before this, the miner wrote straight to disk and
-     * 91% of the brain never reached the index.
-     */
-    private indexer;
-    private emitter;
-    private remover;
-    /**
-     * What this session has actually written, for an honest consolidate().
-     * One per Cortex when a process serves one conversation; in the daemon one
-     * Cortex serves every client, so the tally in force is the one the
-     * connection carries (sessionScope) — otherwise whoever consolidated first
-     * would log, and link with synapses, what the other conversations wrote.
-     */
-    private ownTally;
-    private get tally();
-    constructor(brain: Brain);
-    /** Facts, decisions and neurons touched since the last consolidation. */
-    sessionTally(): {
-        facts: number;
-        decisions: number;
-        topics: string[];
-    };
-    resetSessionTally(): void;
-    setIndexer(indexer: Indexer | null): void;
-    setEmitter(emitter: Emitter | null): void;
-    setRemover(remover: Remover | null): void;
-    private unindex;
-    /**
-     * Copy a whole neuron to .quarantine/ with a timestamp, before anything
-     * destructive. Same stamp format everywhere, so restoreNeuron can pick the
-     * newest copy by name alone.
-     */
-    private quarantine;
-    /** Remove the neuron file, drop its chunks, and keep the manifest honest. */
-    private deleteNeuronFile;
-    private emit;
-    /**
-     * Fusionar contra la versión leída dentro del mismo bloqueo de escritura.
-     * Un snapshot calculado antes del bloqueo puede borrar un learn o retiro.
-     */
-    mergeFromSync(nid: string, ops: Op[]): Promise<{
-        report: MergeReport;
-        created: boolean;
-    }>;
-    private reindex;
-    /**
-     * Get a neuron by ID.
-     */
-    get(id: string): Promise<Neuron | null>;
-    /**
-     * Get a neuron by ID without updating access stats.
-     */
-    peek(id: string): Promise<Neuron | null>;
-    /**
-     * Find a neuron by name.
-     *
-     * Returns null rather than guessing. That is the point: the previous
-     * implementation fell back to substring containment in either direction, so
-     * a two-word topic landed inside any long id that happened to contain it —
-     * a short name like "SEO" was swallowed by a sixty-character neuron whose
-     * title merely mentioned it.
-     * Knowledge written into the wrong neuron is recalled attributed to the
-     * wrong neuron, and no amount of index tuning repairs that. A wrong guess
-     * is worse than a new neuron.
-     */
-    findByName(name: string): Promise<Neuron | null>;
-    /**
-     * Create a new neuron.
-     * Refuses to clobber: two different names can slugify to the same id, and
-     * the old code wrote straight over the existing file, losing every fact in it.
-     */
-    create(name: string, type: NeuronType, domain: string, summary?: string): Promise<Neuron>;
-    /**
-     * Learn — add a fact, decision, pattern or preference to a neuron.
-     * Creates the neuron if it does not exist.
-     */
-    learn(topic: string, type: 'fact' | 'decision' | 'pattern' | 'preference' | 'error' | 'debt', content: string, options?: {
-        confidence?: number;
-        domain?: string;
-        rationale?: string;
-        neuronType?: NeuronType;
-        /** Facts only: words a future question may use that the text does not contain. Indexed, never displayed. */
-        keys?: string[];
-        /**
-         * On an exact-duplicate fact, replace its stored keys with `keys`
-         * instead of merging them. Local only: materialize unions keys across
-         * teammates, so a removed alias does not propagate to their brains.
-         */
-        keysReplace?: boolean;
-        /** Write to this exact neuron and skip name resolution entirely. */
-        neuronId?: string;
-        /** Who is writing: 'session' (default), 'miner', 'manual'. */
-        source?: string;
-        reference?: SourceReference;
-        temporal?: Fact['temporal'];
-        /** Ids or verbatim texts of facts this one replaces. */
-        supersedes?: string[];
-        /**
-         * Facts only: how fast this value goes stale, when the caller says so.
-         * Stored only when given; absent, the class is inferred from the text at
-         * read time. On an exact duplicate a different value replaces the stored one.
-         */
-        shelfLife?: ShelfLife;
-        /**
-         * Create the neuron when the topic is unknown. Default true.
-         * The miner passes false: an automated pass guessing at topic names is
-         * how a brain ends up with a thousand neurons called things like
-         * `lang_pool_8_ball`, each of them shorter -- and therefore
-         * easier to retrieve -- than the knowledge that matters.
-         */
-        createIfMissing?: boolean;
-    }): Promise<{
-        neuron: Neuron | null;
-        /**
-         * `skipped` — no neuron and createIfMissing was false.
-         * `skipped_retired` — the text matches a fact or entry that was retired
-         * (superseded or retracted); nothing was written. Re-learning a retired
-         * line silently would undo a deliberate revision; the caller decides,
-         * with `skipped_retired` in hand, whether to reactivate it instead.
-         */
-        action: 'created' | 'updated' | 'skipped' | 'skipped_retired';
-        superseded: number;
-        /** Supersedes targets that matched no active fact — a silent miss no more. */
-        supersedes_unmatched: string[];
-        /**
-         * Active facts this one closely resembles (Dice ≥ 0.8). The fact is
-         * stored anyway — the brain never refuses knowledge — but the caller is
-         * told, so it can retire the older telling with supersedes/revise
-         * instead of leaving two versions competing on recall.
-         */
-        near_duplicates: Array<{
-            id: string;
-            similarity: number;
-            preview: string;
-        }>;
-        redacted: string[];
-        /** The exact text (case-insensitive) was already an active fact of the neuron. */
-        duplicate: boolean;
-        /** An exact-duplicate fact had its confidence or keys changed by this call. */
-        updated_in_place: boolean;
-        /** Set when the text matches a retired fact/entry; nothing was written. */
-        skipped_retired: {
-            id: string;
-            status: 'superseded' | 'retracted';
-            revised?: string;
-            note?: string;
-        } | null;
-        /** Exact-duplicate fact only: how many times the line has now been learned (2.7). */
-        confirmations?: number;
-        /** Facts only: the shelf-life class that applies, and whether it was inferred from the text (and by which rule). */
-        shelf?: {
-            shelf_life: ShelfLife;
-            inferred: boolean;
-            reason?: ShelfReason;
-        };
-        /** Compatibilidad de lectura: learn ya no produce esta marca. */
-        reconfirmed?: boolean;
-        /** An explicit shelf_life was replaced by a less volatile one (team merge restores the more volatile value). */
-        shelf_lengthened?: boolean;
-    }>;
-    /**
-     * Mark facts as no longer current.
-     *
-     * `superseded` — a newer fact replaces it.
-     * `retracted`  — it was never true.
-     *
-     * Facts are matched by id, and failing that by verbatim text, because the
-     * caller usually has the text in front of it and not the hash.
-     */
-    revise(neuronRef: string, targets: string[], options?: {
-        status?: FactStatus;
-        note?: string;
-        replacedBy?: string;
-    }): Promise<{
-        neuron: Neuron | null;
-        revised: number;
-        unmatched: string[];
-    }>;
-    /**
-     * Reconfirm: the caller checked these lines against their source and they
-     * still hold, so their shelf-life clock restarts now.
-     *
-     * `facts` match ACTIVE facts by id or exact text (trimmed, case-insensitive);
-     * `entries` match live decisions and patterns by entry id or exact text —
-     * the two kinds whose class is durable. A retired fact or entry is not
-     * verifiable: it comes back in `retired` with its status (reactivate it with
-     * status active first, if it holds again), and in `unmatched` like any miss.
-     * Preferences, errors and debts never go stale, so there is nothing to
-     * reconfirm on them; they are unmatched.
-     *
-     * Each stamp is emitted as a verify op, so on a shared neuron a teammate's
-     * clock restarts too: the fact is shared, and so is the world it describes.
-     */
-    verify(neuronRef: string, targets: {
-        facts?: string[];
-        entries?: string[];
-        evidence?: VerificationInput;
-    }): Promise<{
-        neuron: Neuron | null;
-        verified: string[];
-        unmatched: string[];
-        retired: Array<{
-            target: string;
-            id: string;
-            status: 'superseded' | 'retracted';
-        }>;
-    }>;
-    /**
-     * Which active facts does this text closely resemble?
-     *
-     * Warn-only by design. Measured on the reference brain: the heaviest
-     * neuron held 293 facts with 1,407 near-duplicate pairs — session
-     * summaries retelling the same thing with variations, each version as
-     * loud as the others on recall. The fix is the writer retiring the old
-     * telling, never the engine merging on its own.
-     */
-    private findNearDuplicates;
-    /**
-     * Flip matching facts to a non-active status.
-     *
-     * Also reports which targets matched nothing. Callers pass free text, and
-     * a miss used to be indistinguishable from a hit: `supersedes` returned 0
-     * without a word, the writer walked away believing the old version was
-     * retired, and both versions kept surfacing on recall as equals.
-     */
-    private retire;
-    /**
-     * Bring retired facts back. The inverse of retire: only superseded or
-     * retracted facts match, by id or by trimmed lower-cased text. Clears
-     * superseded_by (the replacement no longer replaces it) and stamps the
-     * revision date; the note, if given, records why it came back.
-     */
-    private reactivate;
-    /**
-     * Retire — or reactivate — decisions, patterns, errors and debts by exact
-     * text (trimmed, case-insensitive). These are plain strings, so their
-     * status lives in the entry_status sidecar keyed by entryId(text), the
-     * same way their dates do. A retired entry stays in the file and leaves
-     * recall exactly like a superseded fact; status 'active' deletes the key.
-     *
-     * Never emitted: the sidecar travels only through the local file and
-     * survives a sync because applyOps copies and prunes it.
-     */
-    retireEntries(neuronRef: string, targets: string[], options?: {
-        status?: FactStatus;
-        note?: string;
-    }): Promise<{
-        neuron: Neuron | null;
-        revised: number;
-        unmatched: string[];
-    }>;
-    /**
-     * Edit a neuron's metadata: summary, domain, tags, name.
-     *
-     * Only fields that actually differ are written and reported; a call that
-     * changes nothing writes nothing. `tags` replaces the whole list — protocol
-     * neurons keep their 'priority:'/'source:' tags only if the caller re-sends
-     * them. `name` changes the display name only: the id, and with it the file,
-     * the synapses, the shared map and the connections, never move. `domain`
-     * replaces unconditionally, unlike learn, which only fills in 'general'.
-     *
-     * Not emitted: NeuronOp is only an announcement, and metadata is local.
-     */
-    setMeta(neuronRef: string, meta: {
-        summary?: string;
-        domain?: string;
-        tags?: string[];
-        name?: string;
-    }): Promise<{
-        neuron: Neuron | null;
-        changed: Array<'summary' | 'domain' | 'tags' | 'name'>;
-        redacted: string[];
-    }>;
-    /**
-     * Replace the neuron's system map.
-     *
-     * Whole-document semantics on purpose: a map that can only be appended to
-     * rots the same way facts did — old directions never die. The writer reads
-     * the current map, rewrites it, and stores the new truth. Credentials are
-     * redacted exactly as in learn.
-     */
-    setMap(neuronRef: string, content: string, options?: {
-        domain?: string;
-        neuronType?: NeuronType;
-    }): Promise<{
-        neuron: Neuron | null;
-        action: 'created' | 'updated';
-        redacted: string[];
-    }>;
-    /**
-     * List all neurons with optional filters, and how many matched before paging.
-     *
-     * `list` returns only the page, which made every caller report the page size
-     * as the total — so a client paging through 1,145 neurons was told there were
-     * 50, and stopped. The count here is taken after the filters and before the
-     * slice, which is the only number a pager can trust.
-     */
-    listWithTotal(options?: {
-        domain?: string;
-        type?: NeuronType;
-        min_heat?: number;
-        limit?: number;
-        offset?: number;
-    }): Promise<{
-        total: number;
-        rows: Awaited<ReturnType<Cortex['list']>>;
-    }>;
-    /**
-     * List all neurons with optional filters.
-     */
-    list(options?: {
-        domain?: string;
-        type?: NeuronType;
-        min_heat?: number;
-        limit?: number;
-        /** Rows to skip after the heat sort, for paging. Default 0. */
-        offset?: number;
-    }): Promise<Array<{
-        id: string;
-        name: string;
-        domain: string;
-        type: NeuronType;
-        heat: number;
-        last_accessed: string;
-        facts_count: number;
-    }>>;
-    /**
-     * Update a neuron's summary.
-     */
-    updateSummary(id: string, summary: string): Promise<Neuron | null>;
-    /**
-     * Add tags to a neuron.
-     */
-    addTags(id: string, tags: string[]): Promise<Neuron | null>;
-    /**
-     * Remove facts for good.
-     *
-     * The only destructive operation in CRBRO, so it never edits in place: the
-     * whole neuron is copied to .quarantine/ first, with a timestamp, and can be
-     * put back by hand. Superseding hides a fact; this is for the ones that must
-     * not exist at all — a credential, someone's personal data.
-     */
-    forget(neuronRef: string, targets: string[]): Promise<{
-        neuron_id: string | null;
-        removed: number;
-        backup: string | null;
-    }>;
-    /**
-     * Delete a whole neuron. Quarantine copy first, then the file goes, the
-     * index drops its chunks and the manifest is decremented.
-     *
-     * Synapses are not touched here (the Cortex has no Synapses): the server
-     * calls synapses.removeAllFor(id) right after. Nor is shared state checked
-     * — the server refuses beforehand when the neuron is shared, because the
-     * next sync would simply re-create it from the team log. Nothing is
-     * emitted: there is no neuron-delete op.
-     */
-    forgetNeuron(neuronRef: string): Promise<{
-        neuron_id: string | null;
-        backup: string | null;
-        counts: {
-            facts: number;
-            decisions: number;
-            patterns: number;
-            preferences: number;
-            errors: number;
-            debts: number;
-            connections: number;
-        };
-    }>;
-    /**
-     * Quarantine copies of one neuron, newest first. Stamps sort lexically, so
-     * the file name alone orders them.
-     */
-    private quarantineCopies;
-    /**
-     * Bring a neuron back from quarantine.
-     *
-     * The newest copy is used unless `file` names an exact basename. If the
-     * neuron no longer exists the copy is written back as it was; if it does
-     * (a forget of facts, or the topic was re-created since) the copy is
-     * unioned into it. The quarantine file stays where it is, so a restore is
-     * repeatable. Nothing is emitted.
-     */
-    restoreNeuron(neuronId: string, options?: {
-        file?: string;
-    }): Promise<{
-        neuron: Neuron | null;
-        restored_from: string | null;
-        merged_into_existing: boolean;
-        moved: ReturnType<typeof unionNeuron>['moved'] | null;
-    }>;
-    /**
-     * Fold one neuron into another and delete the first.
-     *
-     * `from` is quarantined, unioned into `into`, and then removed exactly like
-     * forgetNeuron. Each element that actually moved is emitted for `into`, so
-     * a shared target receives the knowledge (the emitter no-ops when `into`
-     * is unshared). Synapses are not touched — the server calls
-     * synapses.rewire(from, into) right after — and the server refuses
-     * beforehand when `from` is shared (unshare first, or the next sync
-     * re-creates it).
-     */
-    mergeNeurons(fromRef: string, intoRef: string): Promise<{
-        from: string | null;
-        into: string | null;
-        backup: string | null;
-        moved: ReturnType<typeof unionNeuron>['moved'] | null;
-    }>;
-    /**
-     * Emit what a union added, by diffing the result against what the target
-     * had. The union is pure, so this is exact: nothing the target already held
-     * is re-announced. The emitter no-ops when the target is not shared.
-     */
-    private emitAdded;
-    /**
-     * Move entries from one neuron to another, whole: text, date, keys,
-     * confidence, retirement. The way to split a neuron that grew past what one
-     * read can carry — learn + forget would do it too, but every entry would be
-     * reborn today and lose the one thing recall uses to tell old from new.
-     *
-     * `targets` are entry ids (factId for facts, entryId for the rest) or exact
-     * texts, any kind. The target neuron is created when missing, with the
-     * source's type and domain. Order is union first, removal second: a crash
-     * in between leaves an entry in both places, never in neither. The source
-     * is quarantined by forget() before anything leaves it. The map never
-     * moves: it describes the system, not an entry.
-     */
-    moveEntries(fromRef: string, targets: string[], intoRef: string, options?: {
-        domain?: string;
-    }): Promise<{
-        from: string | null;
-        into: string | null;
-        created: boolean;
-        moved: number;
-        unmatched: string[];
-        backup: string | null;
-    }>;
-    /**
-     * Fold many small neurons into one digest neuron, in a single pass.
-     *
-     * mergeNeurons would do it one at a time, reindexing a growing target on
-     * every call — quadratic, and minutes on the 766 leftovers this was written
-     * for. Here every source is quarantined, the union is built in memory,
-     * written once and indexed once; only then do the sources go. A source's
-     * NAME is the only context a one-line neuron had ("Phase 1 homepage audit
-     * francortes…"), so its words travel as the fact's keys: searchable, never
-     * shown. The caller picks the sources; nothing here judges them. Unshared
-     * and unconnected sources only — there is no rewiring in this path.
-     */
-    compact(sourceIds: string[], digestName: string, options: {
-        type: NeuronType;
-        domain: string;
-    }): Promise<{
-        into: string | null;
-        folded: string[];
-        skipped: string[];
-        entries: number;
-    }>;
-    /**
-     * Which neurons hold something that looks like a credential.
-     * Reports the kind and where it is, never the value.
-     */
-    auditSecrets(): Promise<Array<{
-        neuron_id: string;
-        name: string;
-        kinds: string[];
-        facts: number;
-        decisions: number;
-        patterns: number;
-        preferences: number;
-        errors: number;
-        debts: number;
-        map: number;
-    }>>;
-    /**
-     * Get all neuron IDs.
-     */
-    allIds(): Promise<string[]>;
-    /**
-     * Count total neurons.
-     */
-    count(): Promise<number>;
-}
-//# sourceMappingURL=cortex.d.ts.map