@hviana/sema 0.1.5 → 0.1.7

package/dist/src/mind/traverse.d.ts

@@ -11,16 +11,24 @@ import type { AncestorReach, MindContext } from "./types.js";
  *  repeatedly — regions sharing a chunk, and canonicalChunkId probing each
  *  chunk's prefixes — so without the memo every repeat re-pays the full
  *  fan-out reads. */
-export declare function edgeAncestors(
-  ctx: MindContext,
-  id: number,
-  contextCount: number,
-  memo?: Map<number, AncestorReach>,
-): AncestorReach;
+export declare function edgeAncestors(ctx: MindContext, id: number, contextCount: number, memo?: Map<number, AncestorReach>): AncestorReach;
 /** Convenience: forward edges of a node. */
 export declare function nextOf(ctx: MindContext, id: number): number[];
 /** Convenience: reverse edges of a node. */
 export declare function prevOf(ctx: MindContext, id: number): number[];
+/** The uniform-expectation floor on a byte atom's corpus commonality: N
+ *  learnt contexts, each at least one perception chunk of up to W of the 256
+ *  possible byte values, contain a given atom in ≥ N·W/256 contexts on
+ *  average.  An atom's TRUE containment is unmeasurable (atoms carry no
+ *  kid/contain links by construction), so this floor is the honest stand-in:
+ *  derived entirely from the corpus scale N, the perception window W, and
+ *  the alphabet size — never tuned. */
+export declare function atomReach(ctx: MindContext, contextCount: number): number;
+/** Whether a byte atom is a hub at this corpus scale — its commonality floor
+ *  {@link atomReach} exceeds the hub bound √N.  Below it (small stores) an
+ *  atom votes and is recognised exactly as any stored form; above it the
+ *  alphabet is scaffolding everywhere and abstains. */
+export declare function atomIsHub(ctx: MindContext, contextCount: number): boolean;
 /** Whether a node LEADS SOMEWHERE — it bears a continuation edge or a halo.
  *  The admission predicate recognition filters sites with (HOW_IT_WORKS
  *  §15.3): a form that leads nowhere contributes nothing to any derivation.
@@ -37,12 +45,7 @@ export declare function leadsSomewhere(ctx: MindContext, id: number): boolean;
  *  half-dominance convention (geometry.dominates(reach, N)): content
  *  reaching a corpus MINORITY of contexts discriminates (an entity, a
  *  filler); content reaching a majority is frame scaffolding. */
-export declare function reachOf(
-  ctx: MindContext,
-  id: number,
-  contextCount: number,
-  memo?: Map<number, AncestorReach>,
-): number;
+export declare function reachOf(ctx: MindContext, id: number, contextCount: number, memo?: Map<number, AncestorReach>): number;
 /** The corpus scale N — the count of DISTINCT learnt contexts, floored at 2
  *  so its derived readings (ln N in the consensus floor, √N in the hub bound)
  *  stay meaningful on a near-empty store.  The one definition every consumer
@@ -58,55 +61,31 @@ export declare function hubBound(ctx: MindContext): number;
  *  §8.6).  A node connected to more than √N others is a hub whose individual
  *  connections carry ~no discriminative information; materialising or scoring
  *  them all would make single decisions scale with the corpus. */
-export declare function hubCap<T>(
-  ctx: MindContext,
-  ids: readonly T[],
-): readonly T[];
+export declare function hubCap<T>(ctx: MindContext, ids: readonly T[]): readonly T[];
 /** Whether `descendant` lies within `ancestor`'s subtree — a structural DAG
  *  relation read off the hash-consed `kids` lists, by a bounded explicit-stack
  *  descent.  Used by articulation to keep a voice from revoicing a fragment
  *  OF that voice. */
-export declare function contains(
-  ctx: MindContext,
-  ancestor: number,
-  descendant: number,
-): boolean;
+export declare function contains(ctx: MindContext, ancestor: number, descendant: number): boolean;
 /** The best-scoring item by cosine against `query`, among items scoring at
  *  or above `threshold` — the shared arg-max every Pattern-A "which of these
  *  resonates best" decision reduces to.  `strict` picks the tie-break a
  *  caller needs: `true` keeps the first-seen leader on a tie (`>`), the
  *  default lets a later equal score take it (`>=`). */
-export declare function argmaxBy<T>(
-  items: Iterable<T>,
-  scoreOf: (item: T) => number,
-  threshold: number,
-  strict?: boolean,
-): {
-  item: T;
-  score: number;
+export declare function argmaxBy<T>(items: Iterable<T>, scoreOf: (item: T) => number, threshold: number, strict?: boolean): {
+    item: T;
+    score: number;
 } | null;
-export declare function argmaxCosine<T>(
-  query: Vec,
-  items: Iterable<T>,
-  vecOf: (item: T) => Vec | null | undefined,
-  threshold: number,
-  strict?: boolean,
-): {
-  item: T;
-  score: number;
+export declare function argmaxCosine<T>(query: Vec, items: Iterable<T>, vecOf: (item: T) => Vec | null | undefined, threshold: number, strict?: boolean): {
+    item: T;
+    score: number;
 } | null;
 /** The guided-or-first continuation of a node, as answer-shaped bytes source:
  *  chooseNext under the response guide, falling back to the FIRST-inserted
  *  edge — the one no-guide convention chooseNext, project() and the search's
  *  formRules all share.  undefined when the node has no continuation. */
-export declare function guidedFirst(
-  ctx: MindContext,
-  id: number,
-): number | undefined;
-export declare function guidedNext(
-  ctx: MindContext,
-  node: number,
-): number | undefined;
+export declare function guidedFirst(ctx: MindContext, id: number): number | undefined;
+export declare function guidedNext(ctx: MindContext, node: number): number | undefined;
 /** Disambiguate among a node's learnt continuations by distributional
  *  support.  NOTE the `guide` contract: its VALUE is deliberately unused —
  *  only its PRESENCE gates disambiguation (a null guide means no query is in
@@ -119,11 +98,7 @@ export declare function guidedNext(
  *  that their perceived gists ARE semantically meaningful — and which
  *  therefore scores by guide cosine.  The two directions consult different
  *  halves of the evidence on purpose. */
-export declare function chooseNext(
-  ctx: MindContext,
-  id: number,
-  guide?: Vec | null,
-): number | undefined;
+export declare function chooseNext(ctx: MindContext, id: number, guide?: Vec | null): number | undefined;
 /** The perceived gist of a candidate node, through the session gist cache.
  *  Re-gisting a candidate is a full river fold of its bytes — the measured
  *  recall bottleneck (a hub context offers up to √N continuations, EACH
@@ -132,11 +107,7 @@ export declare function chooseNext(
  *  every "score node ids against a guide" decision (chooseAmong here, the
  *  bridge's junction pick) so they share ONE cache and one convention. */
 export declare function candidateGist(ctx: MindContext, c: number): Vec | null;
-export declare function chooseAmong(
-  ctx: MindContext,
-  candidates: readonly number[],
-  guide: Vec,
-): {
-  id: number;
-  score: number;
+export declare function chooseAmong(ctx: MindContext, candidates: readonly number[], guide: Vec): {
+    id: number;
+    score: number;
 };