@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0

package/dist/chunk-WU4OTGJE.js

@@ -0,0 +1,752 @@
+// ../../lib/terminals-tech/core/primitives/result.ts
+function ok(value, meta) {
+  return { ok: true, value, meta };
+}
+function err(error, meta) {
+  return { ok: false, error, meta };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+function map(result, fn) {
+  if (isOk(result)) {
+    return ok(fn(result.value), result.meta);
+  }
+  return result;
+}
+function flatMap(result, fn) {
+  if (isOk(result)) {
+    return fn(result.value);
+  }
+  return result;
+}
+
+// ../../lib/terminals-tech/core/primitives/registry.ts
+var BasicRegistry = class {
+  store;
+  config;
+  constructor(config = {}) {
+    this.store = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return void 0;
+    if (this.config.ttlMs && this.isTTLEntry(entry)) {
+      if (Date.now() > entry.expiresAt) {
+        this.store.delete(key);
+        this.config.onExpire?.(key, entry.value);
+        return void 0;
+      }
+      return entry.value;
+    }
+    return entry;
+  }
+  set(key, value) {
+    const entry = this.config.ttlMs ? { value, expiresAt: Date.now() + this.config.ttlMs } : value;
+    this.store.set(key, entry);
+    if (this.config.maxSize && this.store.size > this.config.maxSize) {
+      const firstKey = this.store.keys().next().value;
+      if (firstKey !== void 0) {
+        const firstValue = this.store.get(firstKey);
+        this.store.delete(firstKey);
+        if (firstValue) {
+          const val = this.isTTLEntry(firstValue) ? firstValue.value : firstValue;
+          this.config.onEvict?.(firstKey, val);
+        }
+      }
+    }
+  }
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+  delete(key) {
+    return this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+  size() {
+    this.pruneExpired();
+    return this.store.size;
+  }
+  keys() {
+    this.pruneExpired();
+    return this.store.keys();
+  }
+  values() {
+    this.pruneExpired();
+    const storeValues = Array.from(this.store.values());
+    const isTTLEntry = this.isTTLEntry.bind(this);
+    return (function* () {
+      for (const entry of storeValues) {
+        if (isTTLEntry(entry)) {
+          yield entry.value;
+        } else {
+          yield entry;
+        }
+      }
+    })();
+  }
+  entries() {
+    this.pruneExpired();
+    const storeEntries = Array.from(this.store.entries());
+    const isTTLEntry = this.isTTLEntry.bind(this);
+    return (function* () {
+      for (const [key, entry] of storeEntries) {
+        const value = isTTLEntry(entry) ? entry.value : entry;
+        yield [key, value];
+      }
+    })();
+  }
+  toArray() {
+    return Array.from(this.values());
+  }
+  isTTLEntry(entry) {
+    return typeof entry === "object" && entry !== null && "value" in entry && "expiresAt" in entry && typeof entry.expiresAt === "number";
+  }
+  pruneExpired() {
+    if (!this.config.ttlMs) return;
+    const now = Date.now();
+    const toDelete = [];
+    const entries = Array.from(this.store.entries());
+    for (const [key, entry] of entries) {
+      if (this.isTTLEntry(entry) && now > entry.expiresAt) {
+        toDelete.push(key);
+        this.config.onExpire?.(key, entry.value);
+      }
+    }
+    for (const key of toDelete) {
+      this.store.delete(key);
+    }
+  }
+};
+function createRegistry(config) {
+  return new BasicRegistry(config);
+}
+var GlobalRegistryNamespace = class {
+  namespaces = /* @__PURE__ */ new Map();
+  get(namespace) {
+    let registry = this.namespaces.get(namespace);
+    if (!registry) {
+      registry = createRegistry();
+      this.namespaces.set(namespace, registry);
+    }
+    return registry;
+  }
+  create(namespace, config) {
+    const registry = createRegistry(config);
+    this.namespaces.set(namespace, registry);
+    return registry;
+  }
+  clear(namespace) {
+    if (namespace) {
+      this.namespaces.get(namespace)?.clear();
+    } else {
+      const registryValues = Array.from(this.namespaces.values());
+      for (const registry of registryValues) {
+        registry.clear();
+      }
+      this.namespaces.clear();
+    }
+  }
+};
+var registries = new GlobalRegistryNamespace();
+
+// ../../lib/terminals-tech/core/primitives/dag.ts
+var DAGValidationError = class extends Error {
+  constructor(message, type) {
+    super(message);
+    this.type = type;
+    this.name = "DAGValidationError";
+  }
+};
+var DAGImpl = class {
+  nodes;
+  edges;
+  // Adjacency lists for O(1) neighbor lookup
+  incoming;
+  outgoing;
+  constructor(nodes, edges) {
+    this.nodes = nodes;
+    this.edges = edges;
+    this.incoming = /* @__PURE__ */ new Map();
+    this.outgoing = /* @__PURE__ */ new Map();
+    const nodeKeys = Array.from(nodes.keys());
+    for (const node of nodeKeys) {
+      this.incoming.set(node, []);
+      this.outgoing.set(node, []);
+    }
+    for (const edge of edges) {
+      this.incoming.get(edge.to)?.push(edge);
+      this.outgoing.get(edge.from)?.push(edge);
+    }
+  }
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  getIncoming(nodeId) {
+    return this.incoming.get(nodeId) ?? [];
+  }
+  getOutgoing(nodeId) {
+    return this.outgoing.get(nodeId) ?? [];
+  }
+  getAncestors(nodeId) {
+    const ancestors = /* @__PURE__ */ new Set();
+    const queue = [nodeId];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current) continue;
+      const incoming = this.getIncoming(current);
+      for (const edge of incoming) {
+        if (!ancestors.has(edge.from)) {
+          ancestors.add(edge.from);
+          queue.push(edge.from);
+        }
+      }
+    }
+    return Array.from(ancestors);
+  }
+  getDescendants(nodeId) {
+    const descendants = /* @__PURE__ */ new Set();
+    const queue = [nodeId];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current) continue;
+      const outgoing = this.getOutgoing(current);
+      for (const edge of outgoing) {
+        if (!descendants.has(edge.to)) {
+          descendants.add(edge.to);
+          queue.push(edge.to);
+        }
+      }
+    }
+    return Array.from(descendants);
+  }
+  getRoots() {
+    return Array.from(this.nodes.keys()).filter((id) => this.getIncoming(id).length === 0);
+  }
+  getLeaves() {
+    return Array.from(this.nodes.keys()).filter((id) => this.getOutgoing(id).length === 0);
+  }
+  topologicalSort() {
+    const result = [];
+    const inDegree = /* @__PURE__ */ new Map();
+    const nodeIds = Array.from(this.nodes.keys());
+    for (const id of nodeIds) {
+      inDegree.set(id, this.getIncoming(id).length);
+    }
+    const queue = [];
+    const inDegreeEntries = Array.from(inDegree.entries());
+    for (const [id, degree] of inDegreeEntries) {
+      if (degree === 0) {
+        queue.push(id);
+      }
+    }
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current) continue;
+      result.push(current);
+      for (const edge of this.getOutgoing(current)) {
+        const degree = inDegree.get(edge.to);
+        if (degree === void 0) continue;
+        const newDegree = degree - 1;
+        inDegree.set(edge.to, newDegree);
+        if (newDegree === 0) {
+          queue.push(edge.to);
+        }
+      }
+    }
+    if (result.length !== this.nodes.size) {
+      throw new DAGValidationError("Cannot sort: graph contains cycles", "cycle");
+    }
+    return result;
+  }
+  levels() {
+    const levels = [];
+    const inDegree = /* @__PURE__ */ new Map();
+    const nodeIds = Array.from(this.nodes.keys());
+    for (const id of nodeIds) {
+      inDegree.set(id, this.getIncoming(id).length);
+    }
+    let currentLevel = [];
+    const inDegreeEntries = Array.from(inDegree.entries());
+    for (const [id, degree] of inDegreeEntries) {
+      if (degree === 0) {
+        currentLevel.push(id);
+      }
+    }
+    while (currentLevel.length > 0) {
+      levels.push(currentLevel);
+      const nextLevel = [];
+      for (const nodeId of currentLevel) {
+        for (const edge of this.getOutgoing(nodeId)) {
+          const degree = inDegree.get(edge.to);
+          if (degree === void 0) continue;
+          const newDegree = degree - 1;
+          inDegree.set(edge.to, newDegree);
+          if (newDegree === 0) {
+            nextLevel.push(edge.to);
+          }
+        }
+      }
+      currentLevel = nextLevel;
+    }
+    return levels;
+  }
+  bfs(startId, visitor) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [startId];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current) continue;
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const node = this.nodes.get(current);
+      if (!node) continue;
+      const shouldStop = visitor(node);
+      if (shouldStop === true) return;
+      for (const edge of this.getOutgoing(current)) {
+        if (!visited.has(edge.to)) {
+          queue.push(edge.to);
+        }
+      }
+    }
+  }
+  dfs(startId, visitor) {
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (nodeId) => {
+      if (visited.has(nodeId)) return false;
+      visited.add(nodeId);
+      const node = this.nodes.get(nodeId);
+      if (!node) return false;
+      const shouldStop = visitor(node);
+      if (shouldStop === true) return true;
+      for (const edge of this.getOutgoing(nodeId)) {
+        if (visit(edge.to)) return true;
+      }
+      return false;
+    };
+    visit(startId);
+  }
+  hasCycle() {
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const colors = /* @__PURE__ */ new Map();
+    const nodeIds = Array.from(this.nodes.keys());
+    for (const id of nodeIds) {
+      colors.set(id, WHITE);
+    }
+    const hasCycleUtil = (nodeId) => {
+      colors.set(nodeId, GRAY);
+      for (const edge of this.getOutgoing(nodeId)) {
+        const color = colors.get(edge.to);
+        if (color === GRAY) {
+          return true;
+        }
+        if (color === WHITE && hasCycleUtil(edge.to)) {
+          return true;
+        }
+      }
+      colors.set(nodeId, BLACK);
+      return false;
+    };
+    const allNodeIds = Array.from(this.nodes.keys());
+    for (const id of allNodeIds) {
+      if (colors.get(id) === WHITE) {
+        if (hasCycleUtil(id)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  validate() {
+    const errors = [];
+    if (this.hasCycle()) {
+      errors.push(new DAGValidationError("Graph contains cycles", "cycle"));
+    }
+    for (const edge of this.edges) {
+      if (!this.nodes.has(edge.from)) {
+        errors.push(
+          new DAGValidationError(`Edge references missing node: ${edge.from}`, "missing_node")
+        );
+      }
+      if (!this.nodes.has(edge.to)) {
+        errors.push(
+          new DAGValidationError(`Edge references missing node: ${edge.to}`, "missing_node")
+        );
+      }
+    }
+    for (const edge of this.edges) {
+      if (edge.from === edge.to) {
+        errors.push(
+          new DAGValidationError(`Self-loop detected: ${edge.from} -> ${edge.to}`, "self_loop")
+        );
+      }
+    }
+    if (errors.length > 0) {
+      return { ok: false, error: errors };
+    }
+    return { ok: true, value: void 0 };
+  }
+};
+function createDAG(nodes, edges) {
+  const errors = [];
+  const nodeIds = /* @__PURE__ */ new Set();
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (nodeIds.has(node.id)) {
+      errors.push(new DAGValidationError(`Duplicate node ID: ${node.id}`, "duplicate_node"));
+    } else {
+      nodeIds.add(node.id);
+      nodeMap.set(node.id, node);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, error: errors };
+  }
+  const dag = new DAGImpl(nodeMap, edges);
+  const validationResult = dag.validate();
+  if (validationResult.ok === false) {
+    return { ok: false, error: validationResult.error };
+  }
+  return { ok: true, value: dag };
+}
+
+// ../../lib/terminals-tech/core/primitives/iq.ts
+function assertSameLength(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`I/Q length mismatch: ${a.length} vs ${b.length}`);
+  }
+}
+function l2NormSquared(v) {
+  let s = 0;
+  for (let i = 0; i < v.length; i++) s += v[i] * v[i];
+  return s;
+}
+function dot(a, b) {
+  const n = Math.min(a.length, b.length);
+  let s = 0;
+  for (let i = 0; i < n; i++) s += a[i] * b[i];
+  return s;
+}
+function _private_seedFromVector(v) {
+  const n = v.length;
+  const seed = new Float32Array(n);
+  if (n === 0) return seed;
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    const sign = i % 2 === 0 ? 1 : -1;
+    seed[i] = sign * v[j];
+  }
+  return seed;
+}
+function _private_orthogonalize(seed, against) {
+  const denom = l2NormSquared(against);
+  if (denom <= 0) return seed;
+  const proj = dot(seed, against) / denom;
+  const q = new Float32Array(seed.length);
+  for (let i = 0; i < seed.length; i++) q[i] = seed[i] - proj * against[i];
+  return q;
+}
+function _private_fallbackOrthogonalVector(against) {
+  const n = against.length;
+  const denom = l2NormSquared(against);
+  if (denom <= 0) {
+    const q = new Float32Array(n);
+    if (n > 0) q[0] = 1;
+    return q;
+  }
+  for (let k = 0; k < n; k++) {
+    const seed = new Float32Array(n);
+    seed[k] = 1;
+    const q = _private_orthogonalize(seed, against);
+    const q2 = l2NormSquared(q);
+    if (q2 > 1e-12) return q;
+  }
+  return new Float32Array(n);
+}
+function toIQ(v, opts = {}) {
+  const mode = opts.mode ?? "orthogonalTransform";
+  if (mode === "dualEncoder") {
+    throw new Error("IQ mode 'dualEncoder' is reserved for future explicit I/Q encoders");
+  }
+  const inPhase = v instanceof Float32Array ? new Float32Array(v) : new Float32Array(v);
+  const seed = _private_seedFromVector(inPhase);
+  let quadrature = _private_orthogonalize(seed, inPhase);
+  if (l2NormSquared(quadrature) <= 1e-12) {
+    quadrature = _private_fallbackOrthogonalVector(inPhase);
+  }
+  if (opts.normalizePair) {
+    const total2 = l2NormSquared(inPhase) + l2NormSquared(quadrature);
+    if (total2 > 0) {
+      const inv = 1 / Math.sqrt(total2);
+      for (let i = 0; i < inPhase.length; i++) inPhase[i] *= inv;
+      for (let i = 0; i < quadrature.length; i++) quadrature[i] *= inv;
+    }
+  }
+  return { inPhase, quadrature };
+}
+function phase(iq) {
+  assertSameLength(iq.inPhase, iq.quadrature);
+  const out = new Float32Array(iq.inPhase.length);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Math.atan2(iq.quadrature[i], iq.inPhase[i]);
+  }
+  return out;
+}
+function phaseShift(iq, delta) {
+  assertSameLength(iq.inPhase, iq.quadrature);
+  const c = Math.cos(delta);
+  const s = Math.sin(delta);
+  const I2 = new Float32Array(iq.inPhase.length);
+  const Q2 = new Float32Array(iq.quadrature.length);
+  for (let i = 0; i < iq.inPhase.length; i++) {
+    const I = iq.inPhase[i];
+    const Q = iq.quadrature[i];
+    I2[i] = I * c - Q * s;
+    Q2[i] = I * s + Q * c;
+  }
+  return { inPhase: I2, quadrature: Q2 };
+}
+
+// ../../lib/terminals-tech/core/primitives/phase.ts
+function wrapTo2Pi(theta) {
+  const twoPi = Math.PI * 2;
+  let t = theta % twoPi;
+  if (t < 0) t += twoPi;
+  return t;
+}
+function wrapToPi(theta) {
+  const twoPi = Math.PI * 2;
+  let t = (theta + Math.PI) % twoPi;
+  if (t < 0) t += twoPi;
+  return t - Math.PI;
+}
+function orderParameter(phases) {
+  const n = phases.length;
+  if (n === 0) return { R: 0, psi: 0 };
+  let c = 0;
+  let s = 0;
+  for (let i = 0; i < n; i++) {
+    const t = phases[i];
+    c += Math.cos(t);
+    s += Math.sin(t);
+  }
+  c /= n;
+  s /= n;
+  return { R: Math.hypot(c, s), psi: Math.atan2(s, c) };
+}
+function phaseLockingValue(phiA, phiB) {
+  if (phiA.length !== phiB.length) {
+    throw new Error(`PLV length mismatch: ${phiA.length} vs ${phiB.length}`);
+  }
+  const n = phiA.length;
+  if (n === 0) return 0;
+  let c = 0;
+  let s = 0;
+  for (let i = 0; i < n; i++) {
+    const d = phiA[i] - phiB[i];
+    c += Math.cos(d);
+    s += Math.sin(d);
+  }
+  c /= n;
+  s /= n;
+  return Math.hypot(c, s);
+}
+function kuramotoStep(phases, omega, K, adjacency, dt, opts = {}) {
+  const n = phases.length;
+  const wrap = opts.wrap ?? true;
+  const normalizeCoupling = opts.normalizeCoupling ?? true;
+  const next = new Float32Array(n);
+  const omegaIsScalar = typeof omega === "number";
+  if (!omegaIsScalar && omega.length !== n) {
+    throw new Error(
+      `omega length mismatch: expected ${n}, got ${omega.length}`
+    );
+  }
+  for (let i = 0; i < n; i++) {
+    const thetaI = phases[i];
+    const wI = omegaIsScalar ? omega : omega[i];
+    let couplingSum = 0;
+    let degree = 0;
+    if (adjacency) {
+      const row = adjacency[i];
+      if (!row || row.length !== n) {
+        throw new Error(`adjacency row ${i} length mismatch`);
+      }
+      for (let j = 0; j < n; j++) {
+        if (j === i) continue;
+        const aij = row[j] ?? 0;
+        if (!aij) continue;
+        couplingSum += aij * Math.sin(phases[j] - thetaI);
+        degree += normalizeCoupling ? Math.abs(aij) : 1;
+      }
+    } else {
+      for (let j = 0; j < n; j++) {
+        if (j === i) continue;
+        couplingSum += Math.sin(phases[j] - thetaI);
+      }
+      degree = Math.max(1, n - 1);
+    }
+    const coupling = degree > 0 ? K / degree * couplingSum : 0;
+    const dtheta = wI + coupling;
+    const thetaNext = thetaI + dtheta * dt;
+    next[i] = wrap ? wrapToPi(thetaNext) : thetaNext;
+  }
+  return next;
+}
+
+// ../../lib/terminals-tech/geometry/hyperbolic.ts
+function hyperbolicDistance(u, v) {
+  let uMagSq = 0;
+  let vMagSq = 0;
+  let diffSq = 0;
+  const len = Math.min(u.length, v.length);
+  for (let i = 0; i < len; i++) {
+    const ui = u[i];
+    const vi = v[i];
+    uMagSq += ui * ui;
+    vMagSq += vi * vi;
+    const d = ui - vi;
+    diffSq += d * d;
+  }
+  const safeUMagSq = Math.min(uMagSq, 0.9999);
+  const safeVMagSq = Math.min(vMagSq, 0.9999);
+  const numerator = 2 * diffSq;
+  const denominator = (1 - safeUMagSq) * (1 - safeVMagSq);
+  return Math.acosh(1 + numerator / denominator);
+}
+function hyperbolicResonance(u, v) {
+  const dist = hyperbolicDistance(u, v);
+  return Math.exp(-dist);
+}
+
+// ../../lib/terminals-tech/core/primitives/vector.ts
+function cosineSimilarityAny(a, b) {
+  const n = Math.min(a.length, b.length);
+  let dot2 = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < n; i++) {
+    const ai = a[i];
+    const bi = b[i];
+    dot2 += ai * bi;
+    na += ai * ai;
+    nb += bi * bi;
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  if (denom === 0) return 0;
+  return dot2 / denom;
+}
+
+// ../../lib/terminals-tech/core/primitives/resonance.ts
+function clamp01(x) {
+  if (!Number.isFinite(x)) return 0;
+  return Math.max(0, Math.min(1, x));
+}
+function cosineResonance(a, b) {
+  const cos = cosineSimilarityAny(a, b);
+  return clamp01((cos + 1) / 2);
+}
+function hierarchicalResonance(a, b) {
+  return clamp01(hyperbolicResonance(a, b));
+}
+function iqPhaseLockResonance(a, b) {
+  const phiA = phase(a);
+  const phiB = phase(b);
+  return clamp01(phaseLockingValue(phiA, phiB));
+}
+function blendResonance(components, weights = {}) {
+  const wSemantic = weights.semantic ?? (components.semantic != null ? 1 : 0);
+  const wHier = weights.hierarchical ?? (components.hierarchical != null ? 1 : 0);
+  const wPhase = weights.phaseLock ?? (components.phaseLock != null ? 1 : 0);
+  const denom = wSemantic + wHier + wPhase;
+  if (denom <= 0) return 0;
+  const semantic = components.semantic != null ? clamp01(components.semantic) : 0;
+  const hierarchical = components.hierarchical != null ? clamp01(components.hierarchical) : 0;
+  const phaseLock = components.phaseLock != null ? clamp01(components.phaseLock) : 0;
+  return clamp01((wSemantic * semantic + wHier * hierarchical + wPhase * phaseLock) / denom);
+}
+
+// ../../lib/terminals-tech/core/primitives/delegation.ts
+var SURFACE_IDS = [
+  "chat",
+  "compose",
+  "whiteboard",
+  "world",
+  "skills",
+  "generate",
+  "lobby"
+];
+function isValidSurfaceId(value) {
+  return typeof value === "string" && SURFACE_IDS.includes(value);
+}
+function createDelegationEdge(input) {
+  return {
+    id: `del_${crypto.randomUUID()}`,
+    createdAt: Date.now(),
+    ...input
+  };
+}
+function createDelegationChain(initialEdge, rootInteractionId) {
+  return {
+    id: `dch_${crypto.randomUUID()}`,
+    edges: [initialEdge],
+    rootInteractionId,
+    currentSurface: initialEdge.to.surface
+  };
+}
+
+export {
+  ok,
+  err,
+  isOk,
+  isErr,
+  map,
+  flatMap,
+  createRegistry,
+  createDAG,
+  toIQ,
+  phaseShift,
+  wrapTo2Pi,
+  wrapToPi,
+  orderParameter,
+  phaseLockingValue,
+  kuramotoStep,
+  cosineResonance,
+  hierarchicalResonance,
+  iqPhaseLockResonance,
+  blendResonance,
+  isValidSurfaceId,
+  createDelegationEdge,
+  createDelegationChain
+};
+/**
+ * I/Q (In-phase / Quadrature) Primitives
+ *
+ * Deterministic complex/analytic representation for phase-coherent operations.
+ * This is a minimal L1 primitive: it does not assume a specific embedding model,
+ * only that vectors can be treated as paired (I,Q) components.
+ *
+ * Grounding: https://en.wikipedia.org/wiki/In-phase_and_quadrature_components
+ *
+ * @license BUSL-1.1
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ */
+/**
+ * Hyperbolic Geometry Primitives (Poincaré Ball Model)
+ *
+ * Implements the "Scholze Pyramid" intuition where:
+ * - Center = Abstract Root (Zero) / High Entropy
+ * - Boundary = Rigid State (Ledger) / Low Entropy
+ * - Radius = p-adic Valuation (Specificity)
+ *
+ * @license BUSL-1.1
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ */