@hviana/sema 0.1.5 → 0.1.6

package/dist/src/alu/src/resonance.d.ts

@@ -3,8 +3,8 @@ import type { ResonanceSync } from "./operation.js";
  *  surface forms, as bytes.  The host resonates opaque spans against these to
  *  answer "which operation does this span MEAN?" (see parser.ts AluHost). */
 export interface ConceptAnchor {
-  name: string;
-  form: Uint8Array;
+    name: string;
+    form: Uint8Array;
 }
 /** The async resonance capability the host provides.  Both methods may return
  *  null when resonance finds nothing above the host's own threshold — ALU then
@@ -12,17 +12,17 @@ export interface ConceptAnchor {
  *  keeps synthesis graph-evidenced: ALU never invents meaning resonance did not
  *  supply. */
 export interface AluResonance {
-  /** The canonical operation a span's MEANING names, found by resonance over the
-   *  operation concepts — the GENERIC, modality-agnostic recognition path.  This
-   *  is how an operation that is NOT literally spelled (no "∫" for an integral,
-   *  no "+" for a sum drawn or spoken) is still recognised: the span's gist
-   *  resonates with the operation's concept.  Returns the canonical op name, or
-   *  null when nothing resonates above threshold. */
-  recogniseOp(bytes: Uint8Array): Promise<string | null>;
-  /** The resonant opposite of a symbol's bytes (its antonym / inverse in the
-   *  resonance space, any modality), or null.  The host finds it by halo
-   *  resonance over the negated concept. */
-  opposite(bytes: Uint8Array): Promise<Uint8Array | null>;
+    /** The canonical operation a span's MEANING names, found by resonance over the
+     *  operation concepts — the GENERIC, modality-agnostic recognition path.  This
+     *  is how an operation that is NOT literally spelled (no "∫" for an integral,
+     *  no "+" for a sum drawn or spoken) is still recognised: the span's gist
+     *  resonates with the operation's concept.  Returns the canonical op name, or
+     *  null when nothing resonates above threshold. */
+    recogniseOp(bytes: Uint8Array): Promise<string | null>;
+    /** The resonant opposite of a symbol's bytes (its antonym / inverse in the
+     *  resonance space, any modality), or null.  The host finds it by halo
+     *  resonance over the negated concept. */
+    opposite(bytes: Uint8Array): Promise<Uint8Array | null>;
 }
 /** A AluResonance that knows nothing — the default when the host wires none in,
  *  so the kernel runs fully decoupled (operations resolve by literal forms only,
@@ -34,10 +34,7 @@ export declare const NO_ALU_RESONANCE: AluResonance;
  *  of the bytes (a lossless, stable string key — the same device the search's
  *  chart uses).  This is the async→sync bridge for the polymorphic inverse,
  *  mirroring how a concept hop's target is pre-resolved and read synchronously. */
-export declare function prefetchOpposites(
-  resonance: AluResonance,
-  symbols: Iterable<Uint8Array>,
-): Promise<ResonanceSync>;
+export declare function prefetchOpposites(resonance: AluResonance, symbols: Iterable<Uint8Array>): Promise<ResonanceSync>;
 /** Pre-resolve BOTH capabilities a computation may need synchronously — the
  *  resonant opposite of a symbol (for the polymorphic inverse) AND the operation
  *  a symbol's MEANING names (for a higher-order nd op's function argument) — over
@@ -47,10 +44,7 @@ export declare function prefetchOpposites(
  *  inverse operands and as a reduce/map/filter operator.  Either lookup yields
  *  null for a span that resonates with nothing, so callbacks decline rather than
  *  guess. */
-export declare function prefetchResonance(
-  resonance: AluResonance,
-  spans: Iterable<Uint8Array>,
-): Promise<ResonanceSync>;
+export declare function prefetchResonance(resonance: AluResonance, spans: Iterable<Uint8Array>): Promise<ResonanceSync>;
 /** Pre-resolve, for each candidate span, the operation its MEANING names —
  *  awaiting the host's async gist resonance once per distinct span — and return
  *  a synchronous map keyed by the span's latin1 bytes → canonical op name.  This
@@ -58,7 +52,4 @@ export declare function prefetchResonance(
  *  the literal scan could not classify (no operator symbol) but whose gist
  *  resonates with an operation's concept.  Spans that resonate with nothing are
  *  omitted, so the caller treats a miss as "not an operation". */
-export declare function prefetchRecognisedOps(
-  resonance: AluResonance,
-  spans: Iterable<Uint8Array>,
-): Promise<Map<string, string>>;
+export declare function prefetchRecognisedOps(resonance: AluResonance, spans: Iterable<Uint8Array>): Promise<Map<string, string>>;

package/dist/src/alu/src/resonance.js

@@ -43,8 +43,8 @@ import { latin1 } from "../../bytes.js";
  *  so the kernel runs fully decoupled (operations resolve by literal forms only,
  *  and a symbol inverse is left unchanged). */
 export const NO_ALU_RESONANCE = {
-  recogniseOp: async () => null,
-  opposite: async () => null,
+    recogniseOp: async () => null,
+    opposite: async () => null,
 };
 /** Pre-resolve the resonant opposite of each symbol in `symbols`, awaiting the
  *  host's async resonance once per distinct span, and return a SYNCHRONOUS
@@ -53,25 +53,23 @@ export const NO_ALU_RESONANCE = {
  *  chart uses).  This is the async→sync bridge for the polymorphic inverse,
  *  mirroring how a concept hop's target is pre-resolved and read synchronously. */
 export async function prefetchOpposites(resonance, symbols) {
-  const table = new Map();
-  const seen = new Set();
-  for (const bytes of symbols) {
-    const key = latin1(bytes);
-    if (seen.has(key)) {
-      continue;
+    const table = new Map();
+    const seen = new Set();
+    for (const bytes of symbols) {
+        const key = latin1(bytes);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const opp = await resonance.opposite(bytes);
+        if (opp)
+            table.set(key, opp);
     }
-    seen.add(key);
-    const opp = await resonance.opposite(bytes);
-    if (opp) {
-      table.set(key, opp);
-    }
-  }
-  return {
-    opposite: (bytes) => table.get(latin1(bytes)) ?? null,
-    // Opposites-only prefetch carries no op recognition; a higher-order nd op
-    // resolving through this falls back to literal forms / canonical names.
-    recogniseOp: () => null,
-  };
+    return {
+        opposite: (bytes) => table.get(latin1(bytes)) ?? null,
+        // Opposites-only prefetch carries no op recognition; a higher-order nd op
+        // resolving through this falls back to literal forms / canonical names.
+        recogniseOp: () => null,
+    };
 }
 /** Pre-resolve BOTH capabilities a computation may need synchronously — the
  *  resonant opposite of a symbol (for the polymorphic inverse) AND the operation
@@ -83,30 +81,27 @@ export async function prefetchOpposites(resonance, symbols) {
  *  null for a span that resonates with nothing, so callbacks decline rather than
  *  guess. */
 export async function prefetchResonance(resonance, spans) {
-  const opposites = new Map();
-  const ops = new Map();
-  const seen = new Set();
-  for (const bytes of spans) {
-    const key = latin1(bytes);
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    const [opp, op] = await Promise.all([
-      resonance.opposite(bytes),
-      resonance.recogniseOp(bytes),
-    ]);
-    if (opp) {
-      opposites.set(key, opp);
+    const opposites = new Map();
+    const ops = new Map();
+    const seen = new Set();
+    for (const bytes of spans) {
+        const key = latin1(bytes);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const [opp, op] = await Promise.all([
+            resonance.opposite(bytes),
+            resonance.recogniseOp(bytes),
+        ]);
+        if (opp)
+            opposites.set(key, opp);
+        if (op)
+            ops.set(key, op);
     }
-    if (op) {
-      ops.set(key, op);
-    }
-  }
-  return {
-    opposite: (bytes) => opposites.get(latin1(bytes)) ?? null,
-    recogniseOp: (bytes) => ops.get(latin1(bytes)) ?? null,
-  };
+    return {
+        opposite: (bytes) => opposites.get(latin1(bytes)) ?? null,
+        recogniseOp: (bytes) => ops.get(latin1(bytes)) ?? null,
+    };
 }
 /** Pre-resolve, for each candidate span, the operation its MEANING names —
  *  awaiting the host's async gist resonance once per distinct span — and return
@@ -116,18 +111,16 @@ export async function prefetchResonance(resonance, spans) {
  *  resonates with an operation's concept.  Spans that resonate with nothing are
  *  omitted, so the caller treats a miss as "not an operation". */
 export async function prefetchRecognisedOps(resonance, spans) {
-  const table = new Map();
-  const seen = new Set();
-  for (const bytes of spans) {
-    const key = latin1(bytes);
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    const op = await resonance.recogniseOp(bytes);
-    if (op) {
-      table.set(key, op);
+    const table = new Map();
+    const seen = new Set();
+    for (const bytes of spans) {
+        const key = latin1(bytes);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const op = await resonance.recogniseOp(bytes);
+        if (op)
+            table.set(key, op);
     }
-  }
-  return table;
+    return table;
 }

package/dist/src/alu/src/text.d.ts

@@ -25,11 +25,7 @@ export declare function matchBracket(b: Uint8Array, open: number): number;
 /** The maximal non-whitespace runs of `bytes` within [from, to) — the spacing
  *  floor's reading of "the tokens", shared by the structural host's segmenter
  *  and the parser's term lexing so neither re-implements the walk. */
-export declare function nonSpaceRuns(
-  bytes: Uint8Array,
-  from?: number,
-  to?: number,
-): Array<{
-  i: number;
-  j: number;
+export declare function nonSpaceRuns(bytes: Uint8Array, from?: number, to?: number): Array<{
+    i: number;
+    j: number;
 }>;

package/dist/src/alu/src/text.js

@@ -18,62 +18,56 @@ export const OPEN = 0x5b; // "["
 export const CLOSE = 0x5d; // "]"
 /** ASCII whitespace (space, tab, newline, carriage return) — the one spacing
  *  convention bytes of every textual modality share. */
-export const isSpaceByte = (c) =>
-  c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d;
+export const isSpaceByte = (c) => c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d;
 /** A byte that DELIMITS list elements inside an explicit container: whitespace,
  *  a comma, or a semicolon.  Deliberately excludes anything that can sit inside
  *  a numeral or a symbol token (letters, digits, sign/decimal `+ - .`) and the
  *  brackets themselves, so an element's own bytes are never split. */
-export const isSepByte = (c) =>
-  isSpaceByte(c) || c === 0x2c /* , */ || c === 0x3b /* ; */;
+export const isSepByte = (c) => isSpaceByte(c) || c === 0x2c /* , */ || c === 0x3b /* ; */;
 /** The index of the first non-whitespace byte (or the length, if all space). */
 export function trimStart(b) {
-  let i = 0;
-  while (i < b.length && isSpaceByte(b[i])) {
-    i++;
-  }
-  return i;
+    let i = 0;
+    while (i < b.length && isSpaceByte(b[i]))
+        i++;
+    return i;
 }
 /** The index one past the last non-whitespace byte (or 0, if all space). */
 export function trimEnd(b) {
-  let j = b.length;
-  const lo = trimStart(b);
-  while (j > lo && isSpaceByte(b[j - 1])) {
-    j--;
-  }
-  return j;
+    let j = b.length;
+    const lo = trimStart(b);
+    while (j > lo && isSpaceByte(b[j - 1]))
+        j--;
+    return j;
 }
 /** The index of the `]` matching the `[` at `open`, bracket-depth aware, or -1
  *  when it is unbalanced — used to test whether a span is one explicit list
  *  CONTAINER (its opening bracket closing exactly at its end). */
 export function matchBracket(b, open) {
-  let depth = 0;
-  for (let i = open; i < b.length; i++) {
-    if (b[i] === OPEN) {
-      depth++;
-    } else if (b[i] === CLOSE && --depth === 0) {
-      return i;
+    let depth = 0;
+    for (let i = open; i < b.length; i++) {
+        if (b[i] === OPEN)
+            depth++;
+        else if (b[i] === CLOSE && --depth === 0)
+            return i;
     }
-  }
-  return -1;
+    return -1;
 }
 /** The maximal non-whitespace runs of `bytes` within [from, to) — the spacing
  *  floor's reading of "the tokens", shared by the structural host's segmenter
  *  and the parser's term lexing so neither re-implements the walk. */
 export function nonSpaceRuns(bytes, from = 0, to = bytes.length) {
-  const out = [];
-  let i = from;
-  while (i < to) {
-    if (isSpaceByte(bytes[i])) {
-      i++;
-      continue;
+    const out = [];
+    let i = from;
+    while (i < to) {
+        if (isSpaceByte(bytes[i])) {
+            i++;
+            continue;
+        }
+        let j = i;
+        while (j < to && !isSpaceByte(bytes[j]))
+            j++;
+        out.push({ i, j });
+        i = j;
     }
-    let j = i;
-    while (j < to && !isSpaceByte(bytes[j])) {
-      j++;
-    }
-    out.push({ i, j });
-    i = j;
-  }
-  return out;
+    return out;
 }

package/dist/src/alu/src/value.d.ts

@@ -6,20 +6,20 @@ export type Domain = "bit" | "int" | "real" | "symbol" | "nd";
  *  Values of any domain, so nesting (a matrix = an nd of nd) and heterogeneity
  *  (a list mixing numbers, symbols, sub-lists) are the same case. */
 export type Value = {
-  domain: "bit";
-  b: 0 | 1;
+    domain: "bit";
+    b: 0 | 1;
 } | {
-  domain: "int";
-  n: bigint;
+    domain: "int";
+    n: bigint;
 } | {
-  domain: "real";
-  x: number;
+    domain: "real";
+    x: number;
 } | {
-  domain: "symbol";
-  bytes: Uint8Array;
+    domain: "symbol";
+    bytes: Uint8Array;
 } | {
-  domain: "nd";
-  items: Value[];
+    domain: "nd";
+    items: Value[];
 };
 export declare const bit: (b: 0 | 1) => Value;
 export declare const int: (n: bigint) => Value;
@@ -36,8 +36,8 @@ export declare const tagOf: (v: Value) => Domain;
 export declare function isNumeric(v: Value): boolean;
 /** Whether a value is the n-dimensional container. */
 export declare function isNd(v: Value): v is {
-  domain: "nd";
-  items: Value[];
+    domain: "nd";
+    items: Value[];
 };
 /** Collect, into `out`, every SYMBOL byte span reachable inside a value — itself
  *  when it is a symbol, or each element recursively when it is an nd.  These are
@@ -70,8 +70,8 @@ export declare function joinDomain(args: Value[]): "bit" | "int" | "real";
  *  bytes only through this, so the surrounding system owns how a number is
  *  spelled.  A default ({@link decimalCodec}) is provided. */
 export interface ValueCodec {
-  encode(v: Value): Uint8Array;
-  decode(bytes: Uint8Array): Value | null;
+    encode(v: Value): Uint8Array;
+    decode(bytes: Uint8Array): Value | null;
 }
 /** Parse a byte span into a SCALAR value: a clean integer numeral → exact int, a
  *  fractional/exponent numeral → real, anything else → a symbol carrying its