@hviana/sema 0.8.9 → 0.9.1

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

@@ -1,7 +1,8 @@
 import type { MindContext } from "./types.js";
+import { type ClosureLayer, type DerivationState, type Span } from "./derivation.js";
 import type { Precomputed } from "./pipeline-mechanism.js";
-import { type DerivationState, type Span } from "./derivation.js";
-/** Extend a grounded answer forward across facts (multi-hop reasoning).
+/** Extend a grounded answer forward across facts (multi-hop reasoning) — the
+ *  WALK, run as one layer of the closure engine ({@link walkLayer}).
  *  Pivots on the longest unconsumed learnt context each answer contains,
  *  then follows the pivot's continuation to the next fact.  **The chain ends
  *  when it STOPS, never when a count runs out**: every exit is a refusal (no
@@ -17,11 +18,24 @@ import { type DerivationState, type Span } from "./derivation.js";
  *  response's shared pre-computation — the post-grounding stages read the
  *  same container the mechanisms did. */
 export declare function reason(ctx: MindContext, query: Uint8Array, d0: DerivationState, preConsumed: ReadonlySet<number>, pre: Precomputed, voiced?: readonly Uint8Array[]): Promise<DerivationState>;
+/** The multi-hop walk as a {@link ClosureLayer}: it OFFERS a forward absorb or a
+ *  pivot, the law admits.  Its preamble — the two guards that say the question
+ *  was already answered by the query's own position in the graph, and the
+ *  pre-consumption of what the grounding spoke for — runs on the FIRST offer,
+ *  against the state the engine hands it; a guard that fires makes that first
+ *  offer `null`, so the walk ends where it begins and reports nothing more. */
+export declare function walkLayer(ctx: MindContext, query: Uint8Array, preConsumed: ReadonlySet<number>, pre: Precomputed, voiced?: readonly Uint8Array[]): ClosureLayer;
 /** Fuse independent points of attention into one answer (multi-topic).
  *  When the consensus climb finds more than one dominant point, each
  *  independent point grounds its own answer; they are bridged together
  *  by any learnt connector the graph holds between them. */
-export declare function fuseAttention(ctx: MindContext, query: Uint8Array, state: DerivationState, pre: Precomputed, 
+export declare function fuseAttention(ctx: MindContext, query: Uint8Array, state: DerivationState, pre: Precomputed, unclimbed?: boolean, primarySpans?: ReadonlyArray<Span>): Promise<DerivationState>;
+/** Fusion as a {@link ClosureLayer}: ONE transition, offered once — the fused
+ *  product of the independent points of attention, or nothing.  The law admits
+ *  it (`reaches`: the fusion composed structure this derivation had not stood
+ *  on); the layer's own structural gates below decide whether there is a
+ *  fusion to offer at all. */
+export declare function fusionLayer(ctx: MindContext, query: Uint8Array, pre: Precomputed, 
 /** True when `primary` never touched the consensus climb at all — e.g. a
  *  pure ALU computation, which has no anchor of its own.  commitVotes
  *  ALWAYS admits the dominant root regardless of its vote (attention.ts:
@@ -35,4 +49,4 @@ unclimbed?: boolean,
  *  which is the layer that knows how a given grounding records its evidence;
  *  fuseAttention just reads a position from it.  Empty or absent preserves
  *  the original behaviour exactly. */
-primarySpans?: ReadonlyArray<Span>): Promise<DerivationState>;
+primarySpans?: ReadonlyArray<Span>): ClosureLayer;