zeropoint-node 1.0.7 → 1.0.9

package/src/quantum/composability.ts

@@ -9,7 +9,7 @@
  * modules are interdependent, not in a single sequence.
  */
 
-import { abs, max, min, sqrt, round } from '../0/algebra.ts'
+import { round } from '../0/algebra.ts'
 
 // ============================================================================
 // COMPOSABILITY TYPES: HOW MODULES EXCHANGE DATA

package/src/quantum/end-to-end.ts

@@ -8,9 +8,9 @@
  * Prove: hybrid beats both.
  */
 
-import { abs, max, min, sqrt } from '../0/algebra.ts'
+import '../0/algebra.ts'
 import { extractLearningPatterns, checkVortexInvariants, generateVortexCertificate } from './vortex-bridge.ts'
-import { kernelHintFromQuantum, classicalKernelOptimize, recommendCircuitDepthKernel, decideKernelStrategy } from './kernel-adaptation.ts'
+import { kernelHintFromQuantum, classicalKernelOptimize } from './kernel-adaptation.ts'
 
 export interface EndToEndBenchmark {
   readonly problem: string

package/src/quantum/error-correction.ts

@@ -8,8 +8,8 @@
  * All verified externally: error detection, correction cycles, fidelity gain.
  */
 
-import { floor, abs, max, min, round } from '../0/algebra.ts'
-import { type Register, zeroState, applyGate1, cnot, H, X, Z, probabilities, measureQubit, unitOf } from './simulator.ts'
+import { max, round } from '../0/algebra.ts'
+import { type Register, applyGate1, cnot, H, X, measureQubit, unitOf } from './simulator.ts'
 
 export interface StabilizerCode {
   readonly name: string

package/src/quantum/hardware-compilation.ts

@@ -5,8 +5,8 @@
  * fidelity vs depth trade-offs.
  */
 
-import { PI, sqrt, abs, min, max } from '../0/algebra.ts'
-import { type Gate1, H, X, Y, Z, S, T, phase, rz, ry, rx } from './simulator.ts'
+import { PI, max } from '../0/algebra.ts'
+import { type Gate1, rz, ry, rx } from './simulator.ts'
 
 export interface CompiledCircuit {
   readonly nativeGates: Array<{ q: number; gate: Gate1; name: string }>

package/src/quantum/hybrid.ts

@@ -8,9 +8,9 @@
  * System predicts problem type, routes to best solver, tracks success.
  */
 
-import { sqrt, abs, floor, log2, max, min, round } from '../0/algebra.ts'
+import { sqrt, abs, floor, max, min } from '../0/algebra.ts'
 import { type Register, zeroState, applyGate1, ry, rz, cnot, measureQubit, probabilities, unitOf } from './simulator.ts'
-import { type VQEResult, vqeAdaptive } from './variational-optimizer.ts'
+import { type VQEResult } from './variational-optimizer.ts'
 import { AdaptiveOptimizer } from './adaptive.ts'
 
 // ============================================================================

package/src/quantum/kernel-adaptation.ts

@@ -9,7 +9,7 @@
  * Quantum teaches Classical what works.
  */
 
-import { abs, max, min, round, floor, sqrt } from '../0/algebra.ts'
+import { abs, max, min, floor, sqrt } from '../0/algebra.ts'
 
 // ============================================================================
 // KERNEL HINTS FROM QUANTUM

package/src/quantum/meta-verifier.ts

@@ -10,7 +10,7 @@
  * verification itself.
  */
 
-import { abs, max, min, sqrt } from '../0/algebra.ts'
+import { abs, max, min } from '../0/algebra.ts'
 import type { QuantumLearningPattern } from './vortex-bridge.ts'
 import type { EndToEndBenchmark } from './end-to-end.ts'
 

package/src/quantum/millennium-bridge.ts

@@ -8,7 +8,7 @@
  * The 7 problems are not separate—they are the 7 dimensions of quantum correctness.
  */
 
-import { abs, max, min, sqrt, round } from '../0/algebra.ts'
+import '../0/algebra.ts'
 
 // ============================================================================
 // LAYER 1 ↔ RIEMANN HYPOTHESIS

package/src/quantum/orchestrator.ts

@@ -23,7 +23,7 @@
  * quantum principles applied recursively.
  */
 
-import { abs, max, min, sqrt, round } from '../0/algebra.ts'
+import { abs, min } from '../0/algebra.ts'
 import type { LayerProof } from './proof-of-system.ts'
 import type { MetaVerification } from './meta-verifier.ts'
 import type { CompositionGraph, CompositionPath } from './composability.ts'

package/src/quantum/proof-of-system.ts

@@ -9,7 +9,7 @@
  * and produces a report that proves correctness without trusting any claims.
  */
 
-import { abs, max, min, sqrt, round } from '../0/algebra.ts'
+import { round } from '../0/algebra.ts'
 
 // ============================================================================
 // PROOF: RUN EACH LAYER AND COLLECT EVIDENCE

package/src/quantum/security-bridge.ts

@@ -8,8 +8,8 @@
  * Quantum heuristics guide cryptanalysis strategy selection.
  */
 
-import { abs, max, min, floor, sqrt, log2 } from '../0/algebra.ts'
-import { analyzeRSA } from './applications.ts'
+import { abs, max, min, floor, log2 } from '../0/algebra.ts'
+import './applications.ts'
 
 // ============================================================================
 // CRYPTOGRAPHIC SCHEME ASSESSMENT

package/src/quantum/self-healing.ts

@@ -9,7 +9,7 @@
  * corrected state and try again.
  */
 
-import { abs, max, min, sqrt } from '../0/algebra.ts'
+import { max, min } from '../0/algebra.ts'
 
 // ============================================================================
 // SELF-DIAGNOSIS: DETECT FAILURES

package/src/quantum/tomography.ts

@@ -4,8 +4,8 @@
  * without destroying it — via statistics across many measurement runs.
  */
 
-import { sqrt, abs, floor, log2 } from '../0/algebra.ts'
-import { type Register, zeroState, applyGate1, H, S, cx, measureQubit, probabilities, cabs2, unitOf } from './simulator.ts'
+import { abs, floor, log2 } from '../0/algebra.ts'
+import { type Register, applyGate1, H, measureQubit, probabilities, unitOf } from './simulator.ts'
 
 interface Complex {
   readonly re: number

package/src/quantum/variational-optimizer.ts

@@ -6,13 +6,7 @@
  */
 
 import { PI, sqrt, abs } from '../0/algebra.ts'
-import {
-  type Register,
-  zeroState,
-  applyGate1,
-  ry,
-  rz,
-} from './simulator.ts'
+import { type Register } from './simulator.ts'
 
 export interface OptimizationHistory {
   readonly iteration: number

package/src/quantum/vortex-bridge.ts

@@ -9,7 +9,7 @@
  * Together: discovery + verification = trustworthy innovation.
  */
 
-import { abs, max, min, round, floor } from '../0/algebra.ts'
+import { abs, max, min } from '../0/algebra.ts'
 
 // ============================================================================
 // LEARNING PATTERN EXTRACTION

package/src/quantum/workflow.ts

@@ -11,7 +11,7 @@
 
 import { round, max } from '../0/algebra.ts'
 import { type Register } from './simulator.ts'
-import { type VQEResult, vqeAdaptive } from './variational-optimizer.ts'
+import { vqeAdaptive } from './variational-optimizer.ts'
 import { type CompiledCircuit, type HardwareProfile, transpile } from './hardware-compilation.ts'
 import { AdaptiveOptimizer } from './adaptive.ts'
 

package/src/quantum/zenodo-publisher.ts

@@ -15,7 +15,7 @@
  */
 
 import { createHash } from 'node:crypto'
-import { randomBytes } from 'node:crypto'
+import 'node:crypto'
 import { abs, round } from '../0/algebra.ts'
 
 // ============================================================================

package/src/security/quantum-fold-cipher.test.ts

@@ -6,26 +6,7 @@
  * Principle: No gaps. Every dimension, every fold tier, every security property tested.
  */
 
-import {
-  encodeQuantumState,
-  applyQuantumGate,
-  generateQuantumKey,
-  generateQuantumKeyFromPassword,
-  DEFAULT_SCRYPT,
-  verifyQuantumKey,
-  expandQuantumKeyViaRodin,
-  recordMeasurement,
-  verifyMeasurementReceipt,
-  vortexEncode,
-  vortexDecode,
-  keyspaceBits,
-  keyLengthForBits,
-  DEFAULT_KEY_LENGTH,
-  encryptQuantum,
-  decryptQuantum,
-  QuantumFoldCipher,
-  QuantumEncryption,
-} from './quantum-fold-cipher.ts'
+import { encodeQuantumState, applyQuantumGate, generateQuantumKey, generateQuantumKeyFromPassword, DEFAULT_SCRYPT, verifyQuantumKey, expandQuantumKeyViaRodin, recordMeasurement, verifyMeasurementReceipt, vortexEncode, vortexDecode, keyspaceBits, keyLengthForBits, DEFAULT_KEY_LENGTH, encryptQuantum, decryptQuantum, QuantumFoldCipher, QuantumEncryption } from './quantum-fold-cipher.ts'
 
 const VORTEX_ORBIT = QuantumEncryption.VORTEX_ORBIT
 const TRINITY = QuantumEncryption.TRINITY

package/src/security/quantum-fold-cipher.ts

@@ -16,20 +16,9 @@
  *   Dimension 11:      Compactified       → Unified gate (Tier 5)
  */
 
-import {
-  merge,
-  foldPair,
-  merkleFold,
-  sealFacets,
-  computesGate,
-  toUuid,
-  seedFromText,
-} from '../0/index.ts'
-
-import {
-  digitalRoot,
-  VORTEX_ORBIT,
-} from '../0/index.ts'
+import { merge, foldPair, sealFacets, toUuid } from '../0/index.ts'
+
+import { VORTEX_ORBIT } from '../0/index.ts'
 import { log2, ceil } from '../0/algebra.ts'
 
 // Tier 3 is the CRYPTOGRAPHIC seal, so it uses the SHA-256 path, not the FNV

package/src/security/quantum-proofs.test.ts

@@ -14,18 +14,10 @@
  * reduction, which is exhaustive over {1..9}^6.
  */
 
-import {
-  toUuid, merge, merkleFold, merkleFoldOrdered, digitalRoot, sealFacets, VORTEX_ORBIT,
-} from '../0/index.ts'
-import {
-  vortexEncode, vortexDecode, generateQuantumKey, verifyQuantumKey,
-  expandQuantumKeyViaRodin, recordMeasurement, verifyMeasurementReceipt,
-  encodeQuantumState, QuantumFoldCipher,
-} from './quantum-fold-cipher.ts'
+import { toUuid, merkleFold, merkleFoldOrdered, digitalRoot, sealFacets, VORTEX_ORBIT } from '../0/index.ts'
+import { vortexEncode, vortexDecode, generateQuantumKey, verifyQuantumKey, expandQuantumKeyViaRodin, recordMeasurement, verifyMeasurementReceipt, QuantumFoldCipher } from './quantum-fold-cipher.ts'
 import { computeContentUuid, computeContentDigest } from '../integrity/content-uuid.ts'
-import {
-  proveInstantiationEquivalence, encodeWithShifts, permuteByInversion,
-} from './quantum-threat-landscape.ts'
+import { proveInstantiationEquivalence, encodeWithShifts, permuteByInversion } from './quantum-threat-landscape.ts'
 
 console.log('=== Quantum Proof Verification (computed ranges) ===\n')
 

package/src/security/quantum-threat-landscape.ts

@@ -12,7 +12,7 @@
  * backward are covered by the same security proof.
  */
 
-import { foldPair, foldVortexReflection, toUuid, merkleFold, sealFacets } from '../0/index.ts'
+import '../0/index.ts'
 import { max, log2, floor } from '../0/algebra.ts'
 
 /**

package/src/vbm-demo.ts

@@ -4,7 +4,7 @@
  */
 
 import { PI } from './0/algebra.ts'
-import { VortexMath, VBMNumberAnalyzer, VBMExamples } from './vbm-math.ts';
+import { VortexMath, VBMNumberAnalyzer } from './vbm-math.ts';
 import { AdvancedVBM, RodinCoilCalculator, VBMPatternAnalyzer } from './advanced-vbm.ts';
 
 console.log("🌀 VORTEX BASED MATHEMATICS - TypeScript Implementation");

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.1.2.4.8.7.ts

@@ -1,60 +0,0 @@
-// a432.1.2.4.8.7.ts — Open Vortex/Doubling Stream Module (Short Arc)
-//
-// This module encodes the open doubling sequence (1-2-4-8-7) as a living, recursive stream.
-// It is the generative arc of the vortex, not yet returned to origin. Digital root bridged to a432.roots (Wave 9); stream logic remains local.
-
-/**
- * Metaphysical Principle:
- * - The sequence 1→2→4→8→7 is the open right-hand vortex in vortex math, truncated before further progression.
- * - It is the journey, the generative flow, the living stream before closure or return.
- * - This module is a seed/arc in the living A432 matrix.
- */
-
-// --- Math: Digital Root — bridged to a432.roots (Wave 9) ---
-
-// --- Generator: Open Doubling Vortex Stream ---
-
-
-
-import { legacyDigitalRoot as digitalRoot } from './a432.roots.ts';
-
-function* openDoublingVortexStream(start = 1, length = 5) {
-  let n = start;
-  for (let i = 0; i < length; i++) {
-    yield n;
-    n = digitalRoot(n * 2);
-  }
-}
-
-// --- Utility: Get Sequence as Array ---
-function getOpenDoublingSequence(start = 1, length = 5) {
-  return [...openDoublingVortexStream(start, length)];
-}
-
-// --- Utility: Get Nth in Sequence ---
-function getOpenDoublingNth(start = 1, n = 0) {
-  let val = start;
-  for (let i = 0; i < n; i++) val = digitalRoot(val * 2);
-  return val;
-}
-
-// --- Example Usage ---
-const openSequence = getOpenDoublingSequence(); // [1,2,4,8,7]
-
-// --- Living Stream API ---
-const a432OpenDoublingVortex = {
-  digitalRoot,
-  generator: openDoublingVortexStream,
-  getSequence: getOpenDoublingSequence,
-  getNth: getOpenDoublingNth,
-  open: openSequence,
-  doc: `This module encodes the open, generative doubling vortex (1-2-4-8-7) as a stream, generator, and proof. It is the journey before closure in the A432 matrix.`
-};
-
-// --- Expose globally for debugging (browser only) ---
-if (typeof window !== 'undefined') window.a432OpenDoublingVortex = a432OpenDoublingVortex;
-
-// --- Example: Log the open sequence ---
-if (typeof process !== 'undefined' && process.env?.A432_DIGIT_STREAM_LOG) console.log('A432 Open Doubling Vortex Sequence:', openSequence);
-
-export { digitalRoot, openDoublingVortexStream, getOpenDoublingSequence, getOpenDoublingNth, a432OpenDoublingVortex };

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.1.2.4.8.ts

@@ -1,60 +0,0 @@
-// a432.1.2.4.8.ts — Open Vortex/Doubling Stream Module (Shorter Arc)
-//
-// This module encodes the open doubling sequence (1-2-4-8) as a living, recursive stream.
-// It is the generative arc of the vortex, not yet returned to origin. Digital root bridged to a432.roots (Wave 9); stream logic remains local.
-
-/**
- * Metaphysical Principle:
- * - The sequence 1→2→4→8 is the open right-hand vortex in vortex math, truncated before further progression.
- * - It is the journey, the generative flow, the living stream before closure or return.
- * - This module is a seed/arc in the living A432 matrix.
- */
-
-// --- Math: Digital Root — bridged to a432.roots (Wave 9) ---
-
-// --- Generator: Open Doubling Vortex Stream ---
-
-
-
-import { legacyDigitalRoot as digitalRoot } from './a432.roots.ts';
-
-function* openDoublingVortexStream(start = 1, length = 4) {
-  let n = start;
-  for (let i = 0; i < length; i++) {
-    yield n;
-    n = digitalRoot(n * 2);
-  }
-}
-
-// --- Utility: Get Sequence as Array ---
-function getOpenDoublingSequence(start = 1, length = 4) {
-  return [...openDoublingVortexStream(start, length)];
-}
-
-// --- Utility: Get Nth in Sequence ---
-function getOpenDoublingNth(start = 1, n = 0) {
-  let val = start;
-  for (let i = 0; i < n; i++) val = digitalRoot(val * 2);
-  return val;
-}
-
-// --- Example Usage ---
-const openSequence = getOpenDoublingSequence(); // [1,2,4,8]
-
-// --- Living Stream API ---
-const a432OpenDoublingVortex = {
-  digitalRoot,
-  generator: openDoublingVortexStream,
-  getSequence: getOpenDoublingSequence,
-  getNth: getOpenDoublingNth,
-  open: openSequence,
-  doc: `This module encodes the open, generative doubling vortex (1-2-4-8) as a stream, generator, and proof. It is the journey before closure in the A432 matrix.`
-};
-
-// --- Expose globally for debugging (browser only) ---
-if (typeof window !== 'undefined') window.a432OpenDoublingVortex = a432OpenDoublingVortex;
-
-// --- Example: Log the open sequence ---
-if (typeof process !== 'undefined' && process.env?.A432_DIGIT_STREAM_LOG) console.log('A432 Open Doubling Vortex Sequence:', openSequence);
-
-export { digitalRoot, openDoublingVortexStream, getOpenDoublingSequence, getOpenDoublingNth, a432OpenDoublingVortex };

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.1.2.4.ts

@@ -1,60 +0,0 @@
-// a432.1.2.4.ts — Open Vortex/Doubling Stream Module (Short Arc)
-//
-// This module encodes the open doubling sequence (1-2-4) as a living, recursive stream.
-// It is the generative arc of the vortex, not yet returned to origin. Digital root bridged to a432.roots (Wave 9); stream logic remains local.
-
-/**
- * Metaphysical Principle:
- * - The sequence 1→2→4 is the open right-hand vortex in vortex math, truncated before further progression.
- * - It is the journey, the generative flow, the living stream before closure or return.
- * - This module is a seed/arc in the living A432 matrix.
- */
-
-// --- Math: Digital Root — bridged to a432.roots (Wave 9) ---
-
-// --- Generator: Open Doubling Vortex Stream ---
-
-
-
-import { legacyDigitalRoot as digitalRoot } from './a432.roots.ts';
-
-function* openDoublingVortexStream(start = 1, length = 3) {
-  let n = start;
-  for (let i = 0; i < length; i++) {
-    yield n;
-    n = digitalRoot(n * 2);
-  }
-}
-
-// --- Utility: Get Sequence as Array ---
-function getOpenDoublingSequence(start = 1, length = 3) {
-  return [...openDoublingVortexStream(start, length)];
-}
-
-// --- Utility: Get Nth in Sequence ---
-function getOpenDoublingNth(start = 1, n = 0) {
-  let val = start;
-  for (let i = 0; i < n; i++) val = digitalRoot(val * 2);
-  return val;
-}
-
-// --- Example Usage ---
-const openSequence = getOpenDoublingSequence(); // [1,2,4]
-
-// --- Living Stream API ---
-const a432OpenDoublingVortex = {
-  digitalRoot,
-  generator: openDoublingVortexStream,
-  getSequence: getOpenDoublingSequence,
-  getNth: getOpenDoublingNth,
-  open: openSequence,
-  doc: `This module encodes the open, generative doubling vortex (1-2-4) as a stream, generator, and proof. It is the journey before closure in the A432 matrix.`
-};
-
-// --- Expose globally for debugging (browser only) ---
-if (typeof window !== 'undefined') window.a432OpenDoublingVortex = a432OpenDoublingVortex;
-
-// --- Example: Log the open sequence ---
-if (typeof process !== 'undefined' && process.env?.A432_DIGIT_STREAM_LOG) console.log('A432 Open Doubling Vortex Sequence:', openSequence);
-
-export { digitalRoot, openDoublingVortexStream, getOpenDoublingSequence, getOpenDoublingNth, a432OpenDoublingVortex };

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.3.6.9.trinity.ts

@@ -1,79 +0,0 @@
-// a432.3.6.9.trinity.ts
-// Canonical pregnancy/creation trinity module (3, 6, 9)
-// Encodes metaphysical and mathematical logic of pregnancy, gestation, and birth as a trinity process
-
-import { getTrinityAxis } from './a432.math.ts';
-
-/**
- * Returns the canonical trinity stages of pregnancy: Creation (3), Gestation (6), Birth (9)
- */
-export function getPregnancyTrinityStages() {
-  return [
-    { stage: 1, trinity: 3, name: 'Creation', meaning: 'Conception, seed, initiation' },
-    { stage: 2, trinity: 6, name: 'Gestation', meaning: 'Growth, recursion, nurturing' },
-    { stage: 3, trinity: 9, name: 'Birth', meaning: 'Emergence, unity, manifestation' }
-  ];
-}
-
-/**
- * Returns the canonical gestation cycle as a stream of trinity values (3, 6, 9) repeated for 9 cycles
- */
-export function getGestationCycle(cycles: number = 9) {
-  const trinity = getTrinityAxis();
-  return Array.from({ length: cycles * 3 }, (_, i) => trinity[i % 3]);
-}
-
-/**
- * Returns a metaphysical summary of the pregnancy trinity process
- */
-export function metaphysicalSummary() {
-  return 'Pregnancy is the living trinity: Creation (3), Gestation (6), Birth (9). Each stage is a harmonic act of emergence, recursion, and unity.';
-}
-
-/**
- * Renders a trinity pregnancy visualization as SVG (3 circles, color-coded, with labels)
- */
-export function renderPregnancyTrinityVisualization(currentStage: number = 0): string {
-  const stages = getPregnancyTrinityStages();
-  const colors = ['#39f', '#6f3', '#f93'];
-  const cx = 60, cy = 60, r = 36, gap = 80;
-  return `
-    <svg width="${cx * 4}" height="${cy * 2}" style="background:#111;border-radius:16px;">
-      ${stages.map((s, i) => `
-        <circle cx="${cx + i * gap}" cy="${cy}" r="${i === currentStage ? r + 8 : r}" fill="${colors[i]}" stroke="#fff" stroke-width="2">
-          <title>${s.name}: ${s.meaning}</title>
-          ${i === currentStage ? `<animate attributeName="r" values="${r};${r + 12};${r}" dur="1.2s" repeatCount="indefinite" />` : ''}
-        </circle>
-        <text x="${cx + i * gap}" y="${cy + 6}" text-anchor="middle" font-size="18" fill="#fff">${s.trinity}</text>
-        <text x="${cx + i * gap}" y="${cy + 32}" text-anchor="middle" font-size="13" fill="#ff8">${s.name}</text>
-      `).join('')}
-      <text x="${cx * 2 + gap / 2}" y="${cy * 2 - 8}" text-anchor="middle" font-size="15" fill="#8ff">Pregnancy as Living Trinity (3, 6, 9)</text>
-    </svg>
-  `;
-}
-
-/**
- * Renders a gestation cycle animation as SVG (row of trinity-colored circles, currentIndex pulses)
- */
-export function renderGestationCycleAnimation(currentIndex: number = 0, cycles: number = 9): string {
-  const trinity = getTrinityAxis();
-  const colors = ['#39f', '#6f3', '#f93'];
-  const total = cycles * 3;
-  const r = 14, gap = 36, cx = 24, cy = 32;
-  return `
-    <svg width="${cx * 2 + gap * (total - 1)}" height="${cy * 2}" style="background:#111;border-radius:12px;">
-      ${Array.from({ length: total }, (_, i) => {
-        const t = trinity[i % 3];
-        const color = colors[i % 3];
-        const isCurrent = i === currentIndex;
-        return `
-          <circle cx="${cx + i * gap}" cy="${cy}" r="${isCurrent ? r + 6 : r}" fill="${color}" stroke="#fff" stroke-width="2">
-            <title>Step ${i + 1}: Trinity ${t}</title>
-            ${isCurrent ? `<animate attributeName="r" values="${r};${r + 12};${r}" dur="1.2s" repeatCount="indefinite" />` : ''}
-          </circle>
-          <text x="${cx + i * gap}" y="${cy + 28}" text-anchor="middle" font-size="10" fill="#ff8">${t}</text>
-        `;
-      }).join('')}
-    </svg>
-  `;
-}