@hviana/sema 0.1.4 → 0.1.5

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,7 +34,10 @@ 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
@@ -44,7 +47,10 @@ export declare function prefetchOpposites(resonance: AluResonance, symbols: Iter
  *  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
@@ -52,4 +58,7 @@ export declare function prefetchResonance(resonance: AluResonance, spans: Iterab
  *  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,23 +53,25 @@ 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;
-        seen.add(key);
-        const opp = await resonance.opposite(bytes);
-        if (opp)
-            table.set(key, opp);
+  const table = new Map();
+  const seen = new Set();
+  for (const bytes of symbols) {
+    const key = latin1(bytes);
+    if (seen.has(key)) {
+      continue;
     }
-    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,
-    };
+    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,
+  };
 }
 /** Pre-resolve BOTH capabilities a computation may need synchronously — the
  *  resonant opposite of a symbol (for the polymorphic inverse) AND the operation
@@ -81,27 +83,30 @@ 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);
-        if (op)
-            ops.set(key, op);
+  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);
     }
-    return {
-        opposite: (bytes) => opposites.get(latin1(bytes)) ?? null,
-        recogniseOp: (bytes) => ops.get(latin1(bytes)) ?? null,
-    };
+    if (op) {
+      ops.set(key, op);
+    }
+  }
+  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
@@ -111,16 +116,18 @@ 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,7 +25,11 @@ 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,56 +18,62 @@ 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;
-        }
-        let j = i;
-        while (j < to && !isSpaceByte(bytes[j]))
-            j++;
-        out.push({ i, j });
-        i = j;
+  const out = [];
+  let i = from;
+  while (i < to) {
+    if (isSpaceByte(bytes[i])) {
+      i++;
+      continue;
     }
-    return out;
+    let j = i;
+    while (j < to && !isSpaceByte(bytes[j])) {
+      j++;
+    }
+    out.push({ i, j });
+    i = j;
+  }
+  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