@hviana/sema 0.1.5 → 0.1.6

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

@@ -12,72 +12,36 @@ import type { Input, MindContext } from "./types.js";
  *  O(new nodes) per deposit instead of O(context).  Only the hit node
  *  itself enters `ids`; descendants stay reachable via the memo (see
  *  idOf in indexSubSpans and the changedNodes prune). */
-export declare function internTreeIds(
-  ctx: MindContext,
-  node: Sema,
-  ids: Map<Sema, number>,
-): Promise<number>;
+export declare function internTreeIds(ctx: MindContext, node: Sema, ids: Map<Sema, number>): Promise<number>;
 /** Index flat branches for sub-spans of a deposit's byte stream, linked to
  *  their structural chunks via durable CONTAINMENT edges. */
-export declare function indexSubSpans(
-  ctx: MindContext,
-  tree: Sema,
-  ids: Map<Sema, number>,
-): Promise<boolean>;
+export declare function indexSubSpans(ctx: MindContext, tree: Sema, ids: Map<Sema, number>): Promise<boolean>;
 /** Perceive, intern, and index a single input.  Returns the perceived tree,
  *  root id, id map, and the changed (new) subtrees for halo reinforcement. */
-export declare function deposit(
-  ctx: MindContext,
-  input: Input,
-  track: boolean,
-): Promise<{
-  tree: Sema;
-  rootId: number;
-  ids: Map<Sema, number>;
-  changed: Sema[];
+export declare function deposit(ctx: MindContext, input: Input, track: boolean): Promise<{
+    tree: Sema;
+    rootId: number;
+    ids: Map<Sema, number>;
+    changed: Sema[];
 }>;
 /** Ingest a single input (a bare experience, no continuation). */
-export declare function ingestOne(
-  ctx: MindContext,
-  input: Input,
-): Promise<
-  Sema & {
+export declare function ingestOne(ctx: MindContext, input: Input): Promise<Sema & {
     id: number;
-  }
->;
+}>;
 /** Ingest a pair (context, continuation) — learn an edge and pour halos. */
-export declare function ingestPair(
-  ctx: MindContext,
-  ctxInput: Input,
-  cont: Input,
-): Promise<void>;
+export declare function ingestPair(ctx: MindContext, ctxInput: Input, cont: Input): Promise<void>;
 /** Dispatch the public ingest input shapes onto one-input / pair handlers —
  *  THE one reading of ingest's polymorphic surface (scalar, (context,
  *  continuation) pair, or a list mixing bare inputs and pairs).  Both ingest
  *  paths — the direct one below and {@link CachedIngest} — route through
  *  this, so the shape-detection can never drift between them again (the
  *  ingest cache once re-implemented it and drifted). */
-export declare function dispatchIngest(
-  input: Input | (Input | [Input, Input])[],
-  second: Input | undefined,
-  onOne: (input: Input) => Promise<
-    Sema & {
-      id: number;
-    }
-  >,
-  onPair: (ctxInput: Input, cont: Input) => Promise<void>,
-): Promise<
-  (Sema & {
+export declare function dispatchIngest(input: Input | (Input | [Input, Input])[], second: Input | undefined, onOne: (input: Input) => Promise<Sema & {
+    id: number;
+}>, onPair: (ctxInput: Input, cont: Input) => Promise<void>): Promise<(Sema & {
     id: number;
-  }) | undefined
->;
+}) | undefined>;
 /** Ingest an input or array of inputs/pairs.  The public ingest entry point. */
-export declare function ingest(
-  ctx: MindContext,
-  input: Input | (Input | [Input, Input])[],
-  second?: Input,
-): Promise<
-  (Sema & {
+export declare function ingest(ctx: MindContext, input: Input | (Input | [Input, Input])[], second?: Input): Promise<(Sema & {
     id: number;
-  }) | undefined
->;
+}) | undefined>;

package/dist/src/mind/learning.js

@@ -20,166 +20,152 @@ import { fold as foldVecs } from "../sema.js";
  *  itself enters `ids`; descendants stay reachable via the memo (see
  *  idOf in indexSubSpans and the changedNodes prune). */
 export async function internTreeIds(ctx, node, ids) {
-  const known = ctx._internIds.get(node);
-  if (known !== undefined) {
-    ids.set(node, known);
-    return known;
-  }
-  let id;
-  if (node.kids === null) {
-    id = await ctx.store.putLeaf(node.leaf ?? new Uint8Array(0), node.v);
-  } else {
-    const kds = [];
-    for (const k of node.kids) {
-      kds.push(await internTreeIds(ctx, k, ids));
+    const known = ctx._internIds.get(node);
+    if (known !== undefined) {
+        ids.set(node, known);
+        return known;
     }
-    id = await ctx.store.putBranch(kds, node.v);
-  }
-  ids.set(node, id);
-  ctx._internIds.set(node, id);
-  return id;
+    let id;
+    if (node.kids === null) {
+        id = await ctx.store.putLeaf(node.leaf ?? new Uint8Array(0), node.v);
+    }
+    else {
+        const kds = [];
+        for (const k of node.kids)
+            kds.push(await internTreeIds(ctx, k, ids));
+        id = await ctx.store.putBranch(kds, node.v);
+    }
+    ids.set(node, id);
+    ctx._internIds.set(node, id);
+    return id;
 }
 /** Index flat branches for sub-spans of a deposit's byte stream, linked to
  *  their structural chunks via durable CONTAINMENT edges. */
 export async function indexSubSpans(ctx, tree, ids) {
-  const chunkOf = [];
-  const streamIds = [];
-  const streamVecs = [];
-  const collect = (n) => {
-    if (isChunk(n)) {
-      // A chunk inside a memo-skipped shared subtree is absent from `ids`;
-      // the intern memo still knows it (same object).  A miss on both (the
-      // WeakMap entry was collected) only forfeits the seenBefore skip.
-      const chunkId = ids.get(n) ?? ctx._internIds.get(n);
-      for (const k of n.kids) {
-        const lid = k.leaf ? ctx.store.findLeaf(k.leaf) : null;
-        if (lid === null) {
-          return false;
+    const chunkOf = [];
+    const streamIds = [];
+    const streamVecs = [];
+    const collect = (n) => {
+        if (isChunk(n)) {
+            // A chunk inside a memo-skipped shared subtree is absent from `ids`;
+            // the intern memo still knows it (same object).  A miss on both (the
+            // WeakMap entry was collected) only forfeits the seenBefore skip.
+            const chunkId = ids.get(n) ?? ctx._internIds.get(n);
+            for (const k of n.kids) {
+                const lid = k.leaf ? ctx.store.findLeaf(k.leaf) : null;
+                if (lid === null)
+                    return false;
+                streamIds.push(lid);
+                streamVecs.push(k.v);
+                chunkOf.push(chunkId);
+            }
+            return true;
         }
-        streamIds.push(lid);
-        streamVecs.push(k.v);
-        chunkOf.push(chunkId);
-      }
-      return true;
-    }
-    if (n.kids) {
-      for (const k of n.kids) {
-        if (!collect(k)) {
-          return false;
+        if (n.kids) {
+            for (const k of n.kids)
+                if (!collect(k))
+                    return false;
         }
-      }
-    }
-    return true;
-  };
-  if (!collect(tree)) {
-    return false;
-  }
-  const W = ctx.space.maxGroup; // write side of the canonical contract
-  const prev = ctx._prevSeen;
-  const seenBefore = (off, len) => {
-    if (!prev) {
-      return false;
-    }
-    for (let i = off; i < off + len; i++) {
-      const c = chunkOf[i];
-      if (c === undefined || !prev.has(c)) {
+        return true;
+    };
+    if (!collect(tree))
         return false;
-      }
-    }
-    return true;
-  };
-  const lens = streamIds.length >= W ? canonicalWindows(W) : [streamIds.length];
-  for (const len of lens) {
-    if (len < 1) {
-      continue;
-    }
-    for (let off = 0; off + len <= streamIds.length; off++) {
-      if (seenBefore(off, len)) {
-        continue;
-      }
-      const winIds = streamIds.slice(off, off + len);
-      const flatId = ctx.store.findBranch(winIds) ??
-        await ctx.store.putBranch(
-          winIds,
-          foldVecs(ctx.space, streamVecs.slice(off, off + len)),
-        );
-      for (let i = off; i < off + len; i++) {
-        const c = chunkOf[i];
-        if (c !== undefined) {
-          ctx.store.addContainer(flatId, c);
+    const W = ctx.space.maxGroup; // write side of the canonical contract
+    const prev = ctx._prevSeen;
+    const seenBefore = (off, len) => {
+        if (!prev)
+            return false;
+        for (let i = off; i < off + len; i++) {
+            const c = chunkOf[i];
+            if (c === undefined || !prev.has(c))
+                return false;
+        }
+        return true;
+    };
+    const lens = streamIds.length >= W ? canonicalWindows(W) : [streamIds.length];
+    for (const len of lens) {
+        if (len < 1)
+            continue;
+        for (let off = 0; off + len <= streamIds.length; off++) {
+            if (seenBefore(off, len))
+                continue;
+            const winIds = streamIds.slice(off, off + len);
+            const flatId = ctx.store.findBranch(winIds) ??
+                await ctx.store.putBranch(winIds, foldVecs(ctx.space, streamVecs.slice(off, off + len)));
+            for (let i = off; i < off + len; i++) {
+                const c = chunkOf[i];
+                if (c !== undefined)
+                    ctx.store.addContainer(flatId, c);
+            }
         }
-      }
     }
-  }
-  return true;
+    return true;
 }
 /** Perceive, intern, and index a single input.  Returns the perceived tree,
  *  root id, id map, and the changed (new) subtrees for halo reinforcement. */
 export async function deposit(ctx, input, track) {
-  const bytes = inputBytes(ctx, input);
-  // Deposit-shaped perception: stable-prefix tree SEEDING (see
-  // perceiveDeposit) — an accumulated context re-folds only its new suffix,
-  // O(turn) instead of O(context) per conversation turn.  Cache-only here
-  // (no store-probe fallback): a knownPrefixLength scan on every novel fact
-  // would cost O(n²) hashing, while conversation replays are always warm —
-  // re-deposition replays from the first turn, rebuilding the cache as it
-  // goes.
-  const tree = perceiveDeposit(ctx, bytes);
-  const ids = new Map();
-  const rootId = await internTreeIds(ctx, tree, ids);
-  const indexed = await indexSubSpans(ctx, tree, ids);
-  const leafIds = leafIdPrefix(ctx, bytes);
-  if (leafIds.length === bytes.length && leafIds.length >= 2) {
-    await ctx.store.putBranch(leafIds, tree.v);
-  }
-  const changed = (track && ctx._prevSeen)
-    ? changedNodes(tree, ids, ctx._prevSeen)
-    : [tree];
-  if (track) {
-    ctx._prevSeen = indexed ? new Set(ids.values()) : null;
-  }
-  return { tree, rootId, ids, changed };
+    const bytes = inputBytes(ctx, input);
+    // Deposit-shaped perception: stable-prefix tree SEEDING (see
+    // perceiveDeposit) — an accumulated context re-folds only its new suffix,
+    // O(turn) instead of O(context) per conversation turn.  Cache-only here
+    // (no store-probe fallback): a knownPrefixLength scan on every novel fact
+    // would cost O(n²) hashing, while conversation replays are always warm —
+    // re-deposition replays from the first turn, rebuilding the cache as it
+    // goes.
+    const tree = perceiveDeposit(ctx, bytes);
+    const ids = new Map();
+    const rootId = await internTreeIds(ctx, tree, ids);
+    const indexed = await indexSubSpans(ctx, tree, ids);
+    const leafIds = leafIdPrefix(ctx, bytes);
+    if (leafIds.length === bytes.length && leafIds.length >= 2) {
+        await ctx.store.putBranch(leafIds, tree.v);
+    }
+    const changed = (track && ctx._prevSeen)
+        ? changedNodes(tree, ids, ctx._prevSeen)
+        : [tree];
+    if (track)
+        ctx._prevSeen = indexed ? new Set(ids.values()) : null;
+    return { tree, rootId, ids, changed };
 }
 /** Ingest a single input (a bare experience, no continuation). */
 export async function ingestOne(ctx, input) {
-  const { tree, rootId, ids } = await deposit(ctx, input, true);
-  ctx.store.indexTarget(rootId);
-  const parts = tree.kids ? tree.kids.map((k) => ids.get(k)) : [rootId];
-  const stride = ctx.space.maxGroup;
-  if (parts.length > stride) {
-    for (let i = 0; i + stride < parts.length; i += stride) {
-      await ctx.store.link(parts[i], parts[i + stride]);
-    }
-    if ((parts.length - 1) % stride !== 0) {
-      const lastStart = Math.floor((parts.length - 1) / stride) * stride;
-      if (lastStart < parts.length - 1) {
-        await ctx.store.link(parts[lastStart], parts[parts.length - 1]);
-      }
+    const { tree, rootId, ids } = await deposit(ctx, input, true);
+    ctx.store.indexTarget(rootId);
+    const parts = tree.kids
+        ? tree.kids.map((k) => ids.get(k))
+        : [rootId];
+    const stride = ctx.space.maxGroup;
+    if (parts.length > stride) {
+        for (let i = 0; i + stride < parts.length; i += stride) {
+            await ctx.store.link(parts[i], parts[i + stride]);
+        }
+        if ((parts.length - 1) % stride !== 0) {
+            const lastStart = Math.floor((parts.length - 1) / stride) * stride;
+            if (lastStart < parts.length - 1) {
+                await ctx.store.link(parts[lastStart], parts[parts.length - 1]);
+            }
+        }
     }
-  } else {
-    for (const id of parts) {
-      ctx.store.indexTarget(id);
+    else {
+        for (const id of parts)
+            ctx.store.indexTarget(id);
     }
-  }
-  return Object.assign(tree, { id: rootId });
+    return Object.assign(tree, { id: rootId });
 }
 /** Ingest a pair (context, continuation) — learn an edge and pour halos. */
 export async function ingestPair(ctx, ctxInput, cont) {
-  const c = await deposit(ctx, ctxInput, true);
-  const cont_ = await deposit(ctx, cont, false);
-  const ctxId = c.rootId, contId = cont_.rootId;
-  await ctx.store.link(ctxId, contId);
-  // Halos pour company SIGNATURES (identity), not gists (content) — see
-  // companySignature in sema.ts.
-  const contSeat = bindSeat(ctx.space, companySignature(ctx.space, contId), 1);
-  for (const part of c.changed) {
-    const partId = c.ids.get(part);
-    await ctx.store.pourHalo(partId, contSeat);
-    await ctx.store.pourHalo(
-      contId,
-      bindSeat(ctx.space, companySignature(ctx.space, partId), 0),
-    );
-  }
+    const c = await deposit(ctx, ctxInput, true);
+    const cont_ = await deposit(ctx, cont, false);
+    const ctxId = c.rootId, contId = cont_.rootId;
+    await ctx.store.link(ctxId, contId);
+    // Halos pour company SIGNATURES (identity), not gists (content) — see
+    // companySignature in sema.ts.
+    const contSeat = bindSeat(ctx.space, companySignature(ctx.space, contId), 1);
+    for (const part of c.changed) {
+        const partId = c.ids.get(part);
+        await ctx.store.pourHalo(partId, contSeat);
+        await ctx.store.pourHalo(contId, bindSeat(ctx.space, companySignature(ctx.space, partId), 0));
+    }
 }
 /** Dispatch the public ingest input shapes onto one-input / pair handlers —
  *  THE one reading of ingest's polymorphic surface (scalar, (context,
@@ -188,36 +174,28 @@ export async function ingestPair(ctx, ctxInput, cont) {
  *  this, so the shape-detection can never drift between them again (the
  *  ingest cache once re-implemented it and drifted). */
 export async function dispatchIngest(input, second, onOne, onPair) {
-  if (
-    Array.isArray(input) && !(input instanceof Uint8Array) &&
-    input.width === undefined
-  ) {
-    const arr = input;
-    if (arr.length === 2 && !Array.isArray(arr[0]) && !Array.isArray(arr[1])) {
-      await onPair(arr[0], arr[1]);
-      return undefined;
-    }
-    for (const item of arr) {
-      if (Array.isArray(item) && item.length === 2) {
-        await onPair(item[0], item[1]);
-      } else {
-        await onOne(item);
-      }
+    if (Array.isArray(input) && !(input instanceof Uint8Array) &&
+        input.width === undefined) {
+        const arr = input;
+        if (arr.length === 2 && !Array.isArray(arr[0]) && !Array.isArray(arr[1])) {
+            await onPair(arr[0], arr[1]);
+            return undefined;
+        }
+        for (const item of arr) {
+            if (Array.isArray(item) && item.length === 2) {
+                await onPair(item[0], item[1]);
+            }
+            else
+                await onOne(item);
+        }
+        return undefined;
     }
+    if (second === undefined)
+        return onOne(input);
+    await onPair(input, second);
     return undefined;
-  }
-  if (second === undefined) {
-    return onOne(input);
-  }
-  await onPair(input, second);
-  return undefined;
 }
 /** Ingest an input or array of inputs/pairs.  The public ingest entry point. */
 export async function ingest(ctx, input, second) {
-  return dispatchIngest(
-    input,
-    second,
-    (i) => ingestOne(ctx, i),
-    (a, b) => ingestPair(ctx, a, b),
-  );
+    return dispatchIngest(input, second, (i) => ingestOne(ctx, i), (a, b) => ingestPair(ctx, a, b));
 }

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

@@ -14,27 +14,17 @@ import type { Site } from "./graph-search.js";
  *                (gate: identityBar — scale-aware).
  *
  *  Returns the absolute byte position, or −1. */
-export declare function locate(
-  ctx: MindContext,
-  haystack: Uint8Array,
-  needle: Uint8Array,
-  fromPos: number,
-  sites?: ReadonlyArray<Site>,
-): number;
+export declare function locate(ctx: MindContext, haystack: Uint8Array, needle: Uint8Array, fromPos: number, sites?: ReadonlyArray<Site>): number;
 /** The ALIGNED matcher: maximal literal matching runs between `query` and
  *  `ct` (a learned context's bytes), by seed-and-extend over
  *  `space.maxGroup`-sized n-gram seeds.  Where locate() finds ONE position of
  *  a short frame, this finds EVERY run two whole structures share — the
  *  matcher CAST detects a woven query with.  Returns non-overlapping runs
  *  sorted by query position. */
-export declare function alignRuns(
-  ctx: MindContext,
-  query: Uint8Array,
-  ct: Uint8Array,
-): Array<{
-  qs: number;
-  qe: number;
-  cs: number;
+export declare function alignRuns(ctx: MindContext, query: Uint8Array, ct: Uint8Array): Array<{
+    qs: number;
+    qe: number;
+    cs: number;
 }>;
 /** A run from {@link alignGraded} — the ALIGNED matcher extended with the
  *  same graded-evidence ladder as {@link locate}.  Literal runs carry
@@ -44,10 +34,10 @@ export declare function alignRuns(
  *  kind, so the substitution/redirection schemas work unchanged on conceptual
  *  alignment. */
 export interface GradedRun {
-  qs: number;
-  qe: number;
-  cs: number;
-  weight: number;
+    qs: number;
+    qe: number;
+    cs: number;
+    weight: number;
 }
 /** The GRADED alignment matcher: extends literal W-gram alignment
  *  ({@link alignRuns}) with halo-matched recognised sites in query regions
@@ -59,42 +49,23 @@ export interface GradedRun {
  *  `querySites` are the pre-computed recognition sites for the query
  *  (optional — when absent, only literal alignment fires and graded degrades
  *  to the original behaviour).  Context sites are recognised internally. */
-export declare function alignGraded(
-  ctx: MindContext,
-  query: Uint8Array,
-  contextBytes: Uint8Array,
-  querySites?: ReadonlyArray<Site>,
-): GradedRun[];
+export declare function alignGraded(ctx: MindContext, query: Uint8Array, contextBytes: Uint8Array, querySites?: ReadonlyArray<Site>): GradedRun[];
 /** The IN-LIST halo matcher: the best halo-mate for `halo` among EXPLICIT
  *  candidates, above the concept threshold — the list counterpart of
  *  {@link haloSiblings}, which asks the halo INDEX for candidates instead.
  *  Behind locate()'s halo step and articulation's voice matching; a third
  *  "best halo among these" decision must come here, not inline. */
-export declare function bestHaloMate<T>(
-  ctx: MindContext,
-  halo: Vec,
-  items: Iterable<T>,
-  haloOf: (item: T) => Vec | null | undefined,
-): {
-  item: T;
-  score: number;
+export declare function bestHaloMate<T>(ctx: MindContext, halo: Vec, items: Iterable<T>, haloOf: (item: T) => Vec | null | undefined): {
+    item: T;
+    score: number;
 } | null;
-export declare function haloSiblings(
-  ctx: MindContext,
-  id: number,
-  halo?: Vec | null,
-  bar?: number,
-): Promise<Hit[]>;
+export declare function haloSiblings(ctx: MindContext, id: number, halo?: Vec | null, bar?: number): Promise<Hit[]>;
 /** The DISTRIBUTIONAL matcher between two nodes: mutual-nearest-neighbour
  *  strength, not a pick.  Returns the direct halo cosine, or failing that the
  *  highest mutual-halo-sibling min-score (second-order analogy), or failing
  *  that the SHARED-FRAME strength (below) — the gate CAST's comparison
  *  schema validates genuine analogs with (bar: significanceBar). */
-export declare function analogyStrength(
-  ctx: MindContext,
-  a: number,
-  b: number,
-): Promise<number>;
+export declare function analogyStrength(ctx: MindContext, a: number, b: number): Promise<number>;
 /** The STRUCTURAL analogy tier: two nodes are analogs when their byte
  *  streams share a LEARNT frame — a content-addressed flat form of at least
  *  one full river window (W bytes, the perception quantum) that occurs in
@@ -107,28 +78,17 @@ export declare function analogyStrength(
  *  a fraction, comparable to the cosine tiers above.  Derived: the window
  *  is maxGroup, the same quantum differsByOneWindow and canonicalChunkId
  *  measure by; no tuned constants. */
-export declare function sharedFrameStrength(
-  ctx: MindContext,
-  a: number,
-  b: number,
-): number;
+export declare function sharedFrameStrength(ctx: MindContext, a: number, b: number): number;
 /** FORWARD through a synonym: the continuation an edge-less node borrows from
  *  a concept (halo) sibling — resonate the node's halo, take the first
  *  sibling above the concept threshold that itself has a direct edge. */
-export declare function conceptHop(
-  ctx: MindContext,
-  id: number,
-): Promise<number | null>;
+export declare function conceptHop(ctx: MindContext, id: number): Promise<number | null>;
 /** FORWARD projection: follow continuation edges from a node to its fixpoint.
  *  The first hop may cross a concept (halo) link — a synonym.  The rest
  *  follow direct edges.  Convergence is intrinsic: the seen set guards
  *  against cycles.  `guide` disambiguates multi-continuation nodes by
  *  resonance. */
-export declare function follow(
-  ctx: MindContext,
-  id: number,
-  guide?: Vec | null,
-): Promise<Uint8Array | null>;
+export declare function follow(ctx: MindContext, id: number, guide?: Vec | null): Promise<Uint8Array | null>;
 /** REVERSE projection: the context a learnt continuation follows, voiced as
  *  bytes.  A common continuation ("Yes.") follows MANY contexts; with a
  *  `guide` the context whose gist resonates with the query wins (seat
@@ -143,18 +103,9 @@ export declare function follow(
  *  context reads empty (a zero-length context is no grounding: an empty
  *  Uint8Array is truthy, and returning it would flow a hollow "answer"
  *  onward). */
-export declare function reverseContext(
-  ctx: MindContext,
-  id: number,
-  guide?: Vec | null,
-  rev?: readonly number[],
-): Uint8Array | null;
+export declare function reverseContext(ctx: MindContext, id: number, guide?: Vec | null, rev?: readonly number[]): Uint8Array | null;
 /** THE projection: ground a matched node to answer bytes — FORWARD to its
  *  continuation fixpoint (which may cross a concept hop), else REVERSE to
  *  the context it follows.  This is the direction ladder every mechanism's
  *  final grounding step reduces to. */
-export declare function project(
-  ctx: MindContext,
-  id: number,
-  guide?: Vec | null,
-): Promise<Uint8Array | null>;
+export declare function project(ctx: MindContext, id: number, guide?: Vec | null): Promise<Uint8Array | null>;