zeropoint-node 1.0.8 → 1.0.9

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

@@ -13,14 +13,7 @@
  */
 
 import { abs, round } from './a432.algebra.ts'
-import { 
-  RODIN_SEQUENCE, 
-  TRINITY_AXIS, 
-  digitalRoot, 
-  angleForDigit,
-  frequencyForDigit,
-  hueForDigit 
-} from './a432.math.ts';
+import { frequencyForDigit, hueForDigit } from './a432.math.ts';
 
 // --- Canonical Rodin Coil Constants ---
 const RODIN_COIL_CORE = [1, 2, 4, 8, 7, 5]; // Lossless kinetic energy
@@ -132,7 +125,7 @@ function generateRodinCoilColor(digit: number): string {
   const x = c * (1 - abs((h * 6) % 2 - 1));
   const m = v - c;
   
-  let r = 0, g = 0, b = 0;
+  let r: number, g: number, b: number;
   
   if (h < 1/6) [r, g, b] = [c, x, 0];
   else if (h < 2/6) [r, g, b] = [x, c, 0];

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

@@ -1,5 +1,5 @@
 import { pathToFileURL } from 'node:url'
-import { log } from './a432.algebra.ts'
+import './a432.algebra.ts'
 // @ts-nocheck
 /**
  * a432.rodin.ts — Science & Math extraction from the Rodin book

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

@@ -14,26 +14,9 @@
  */
 
 import { abs, sqrt } from './a432.algebra.ts'
-import {
-  A432_FREQUENCY,
-  A432_TRINITY,
-  A432_RETURN,
-  A432_AXIS,
-  A432_CYCLE,
-  digitalRoot,
-  a432Frequency,
-  a432HSLFromRoot,
-  a432RGBFromRoot
-} from './a432.core.ts';
-
-import { 
-  GOLDEN_RATIO, 
-  GOLDEN_RATIO_SQUARED, 
-  PI, 
-  SQRT_2, 
-  SQRT_3,
-  SACRED_GEOMETRY_RATIOS 
-} from './a432.math.constants.ts';
+import { A432_FREQUENCY, digitalRoot, a432Frequency, a432HSLFromRoot } from './a432.core.ts';
+
+import { GOLDEN_RATIO, PI, SQRT_2, SQRT_3 } from './a432.math.constants.ts';
 
 // === SACRED GEOMETRIC CONSTANTS ===
 // These define all mathematical relationships through sacred geometry

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

@@ -7,9 +7,9 @@
 import { min } from './a432.algebra.ts'
 import { A432System } from './a432.index.ts';
 import { A432NavigationMap } from './a432.navigation.map.ts';
-import { A432Factory, createA432State } from './a432.factory.ts';
+import { A432Factory } from './a432.factory.ts';
 import { A432Math, A432Sequence, A432Harmonization } from './a432.utils.ts';
-import { A432Registry, registerA432Component } from './a432.registry.ts';
+import { A432Registry } from './a432.registry.ts';
 
 // === SELF-EVOLUTION INTERFACES ===
 export interface A432SelfEvolutionState {

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

@@ -6,7 +6,7 @@
 
 import { A432SelfEvolution, type A432SelfGeneratedModule } from './a432.self.evolution.ts';
 import { A432System } from './a432.index.ts';
-import { A432Math, A432Sequence } from './a432.utils.ts';
+import { A432Math } from './a432.utils.ts';
 import { A432Registry } from './a432.registry.ts';
 
 // === SELF-REBUILDER INTERFACES ===
@@ -192,7 +192,7 @@ export class A432SelfRebuilder {
  * Evolution: ${module.evolution}
  */
 
-import { A432Math, A432Sequence, A432Harmonization } from '../a432.utils.ts';
+import { A432Math, A432Harmonization } from '../a432.utils.ts';
 import { A432Factory } from '../a432.factory.ts';
 import { A432Registry } from '../a432.registry.ts';
 

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

@@ -12,10 +12,10 @@ import { legacyDigitalRoot } from './a432.roots.ts'
 import { EventEmitter } from 'events';
 import fs from 'fs';
 import path from 'path';
-import { digitAngleToCMYK, asAngle, digitalRoot } from './a432.math.ts';
+import { digitAngleToCMYK, asAngle } from './a432.math.ts';
 import { type Digit } from './a432.types.ts';
 import { impossibilityCMYK } from './a432.impossible.ts';
-import { challengeCMYK, CHALLENGES } from './a432.challenge.ts';
+import './a432.challenge.ts';
 import type { CMYK } from './a432.cmyk.ts';
 
 // Canonical directory (this file lives in it)

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

@@ -10,17 +10,7 @@
  */
 
 import { min } from './a432.algebra.ts'
-import { 
-  A432_FREQUENCY, 
-  A432_TRINITY, 
-  A432_RETURN, 
-  A432_AXIS, 
-  A432_CYCLE,
-  digitalRoot,
-  a432Frequency,
-  a432HSLFromRoot,
-  a432RGBFromRoot
-} from './a432.core.ts';
+import { digitalRoot, a432Frequency, a432HSLFromRoot, a432RGBFromRoot } from './a432.core.ts';
 
 // === A432 SEQUENCE CONSTANTS ===
 export const A432_SEQUENCE_CONSTANTS = {

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

@@ -16,52 +16,17 @@
 import express from 'express';
 import type { Request, Response } from 'express';
 import path from 'path';
-import { 
-  resolveDivision, 
-  digitAngleToCMYK, 
-  asAngle, 
-  possibilityPath, 
-  getRodinSequence,
-  analyzeRodinCoilPattern,
-  getRodinCoilHarmonicAnalysis,
-  RODIN_COIL_CORE,
-  RODIN_COIL_DIPOLES,
-  RODIN_COIL_MONOPOLE,
-  RODIN_COIL_GAP_SPACE
-} from './a432.math.ts';
-import {
-  analyzeTripleMerkabaGeometry,
-  getTripleMerkabaFrequencyMapping,
-  getTripleMerkabaVisualization,
-  TRIPLE_MERKABA_CONSTANTS,
-  FREQUENCY_MAPPING
-} from './a432.triple.merkaba.ts';
-import {
-  initializeA432TripleMerkaba3D,
-  updateA432TripleMerkaba3D,
-  generateA432TripleMerkaba3DScene,
-  A432_3D_CONSTANTS
-} from './a432.triple.merkaba.3d.ts';
-import {
-  initializeA432ConsciousnessJourney,
-  updateA432ConsciousnessJourney,
-  generateA432ConsciousnessJourneyScene,
-  CONSCIOUSNESS_STATES,
-  CONSCIOUSNESS_JOURNEY
-} from './a432.consciousness.journey.3d.ts';
-import {
-  initializeA432Multidimensional,
-  updateA432Multidimensional,
-  generateA432MultidimensionalScene,
-  MULTIDIMENSIONAL_CONSCIOUSNESS,
-  MULTIDIMENSIONAL_PATHS
-} from './a432.multidimensional.consciousness.3d.ts';
+import { resolveDivision, digitAngleToCMYK, asAngle, possibilityPath, getRodinSequence, analyzeRodinCoilPattern, getRodinCoilHarmonicAnalysis, RODIN_COIL_CORE, RODIN_COIL_DIPOLES, RODIN_COIL_MONOPOLE, RODIN_COIL_GAP_SPACE } from './a432.math.ts';
+import { analyzeTripleMerkabaGeometry, getTripleMerkabaFrequencyMapping, getTripleMerkabaVisualization, TRIPLE_MERKABA_CONSTANTS, FREQUENCY_MAPPING } from './a432.triple.merkaba.ts';
+import { initializeA432TripleMerkaba3D, updateA432TripleMerkaba3D, generateA432TripleMerkaba3DScene, A432_3D_CONSTANTS } from './a432.triple.merkaba.3d.ts';
+import { initializeA432ConsciousnessJourney, updateA432ConsciousnessJourney, generateA432ConsciousnessJourneyScene, CONSCIOUSNESS_STATES, CONSCIOUSNESS_JOURNEY } from './a432.consciousness.journey.3d.ts';
+import { initializeA432Multidimensional, updateA432Multidimensional, generateA432MultidimensionalScene, MULTIDIMENSIONAL_CONSCIOUSNESS, MULTIDIMENSIONAL_PATHS } from './a432.multidimensional.consciousness.3d.ts';
 // Matrix Terminal harmonized into HTML - no separate TypeScript module needed
 import { handleImpossible } from './a432.impossible.ts';
 import { asDigit } from './a432.types.ts';
 import { execSync } from 'child_process';
-import { pulse } from './a432.graph.ts';
-import { executeOSCommand } from './a432.os.terminal.ts';
+import './a432.graph.ts';
+import './a432.os.terminal.ts';
 import { getConsciousnessStream, evolveConsciousnessStream } from './a432.consciousness.stream.ts';
 import fs from 'fs';
 import util from 'util';

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

@@ -11,7 +11,7 @@
  * Source: Marko Rodin Special Edition, Chapter 10
  */
 
-import { legacyDigitalRoot as digitalRoot, harmonicRoot12 } from './a432.roots.ts'
+import './a432.roots.ts'
 /**
  * a432ElectronShear: Returns the canonical electron harmonic shears (1, 4, 7).
  */

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

@@ -14,7 +14,7 @@ import { PI, sin } from './a432.algebra.ts'
  * This ensures metaphysical duality, reversibility, and the living, analog nature of streams, as required by the A432 system.
  */
 // π-based stream sources
-import { piStream, piColorStream, piHarmonicStream } from './a432.pi.ts';
+import { piColorStream, piHarmonicStream } from './a432.pi.ts';
 // Specialized π-based stream modules
 import * as PiColor from './a432.pi.color.stream.ts';
 import * as PiSong from './a432.pi.song.stream.ts';

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

@@ -1,4 +1,4 @@
-import { log } from './a432.algebra.ts'
+import './a432.algebra.ts'
 import { Controller } from '@hotwired/stimulus';
 import { startTerminal } from './a432.terminal.ui.ts';
 

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

@@ -16,7 +16,7 @@
 
 import { PI, abs, cos, floor, min, round, sin, sqrt } from './a432.algebra.ts'
 import { digitAngleToCMYK, cmykToCss, type CMYK } from './a432.cmyk.ts';
-import { A432_FREQUENCY, A432_TRINITY, A432_RETURN, A432_AXIS, digitalRoot } from './a432.core.ts';
+import { A432_FREQUENCY } from './a432.core.ts';
 import { TRINITY_AXIS, RODIN_SEQUENCE } from './a432.math.ts';
 export { TRINITY_AXIS, RODIN_SEQUENCE };
 

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

@@ -9,17 +9,8 @@
  */
 
 import { PI, cos, sin } from './a432.algebra.ts'
-import {
-  A432_TRINITY,
-  A432_RETURN,
-  A432_AXIS,
-  A432_SEQUENCE,
-  digitalRoot,
-  angleForDigit,
-  frequencyForDigit,
-  hueForDigit
-} from './a432.math.ts';
-import { digitAngleToCMYK, cmykToCss } from './a432.cmyk.ts';
+import { A432_TRINITY, A432_AXIS, A432_SEQUENCE, digitalRoot, angleForDigit, frequencyForDigit } from './a432.math.ts';
+import './a432.cmyk.ts';
 
 // A432-derived 3D constants
 export const A432_3D_CONSTANTS = {

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

@@ -9,16 +9,7 @@
  * @author A432 System
  */
 
-import {
-  A432_TRINITY,
-  A432_RETURN,
-  A432_AXIS,
-  A432_SEQUENCE,
-  digitalRoot,
-  angleForDigit,
-  frequencyForDigit,
-  hueForDigit
-} from './a432.math.ts';
+import { digitalRoot, frequencyForDigit } from './a432.math.ts';
 import { digitAngleToCMYK, cmykToCss } from './a432.cmyk.ts';
 
 // Triple Merkaba Geometry Constants

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

@@ -12,11 +12,11 @@
 import { PI, TAU, floor, indexFromSeed, min, round } from './a432.algebra.ts'
 import { A432_FREQUENCY as A432_HZ } from './a432.core.ts'
 // Import all A432 modules
-import { A432Eye, A432_EYE_CONSTANTS, eyeHarmonization, eyeAnalysis, eyeControl, defaultEye } from './a432.eye.ts';
-import { A432EyeSeeAll, A432_EYE_SEE_ALL_CONSTANTS, seeAllHarmonization, seeAllAnalysis, seeAllControl, defaultSeeAll } from './a432.eye.see.all.ts';
-import { A432IImagine, A432_I_IMAGINE_CONSTANTS, iImagineHarmonization, iImagineAnalysis, iImagineControl, defaultIImagine } from './a432.i.imagine.ts';
-import { A432ILive, A432_I_LIVE_CONSTANTS, iLiveHarmonization, iLiveAnalysis, iLiveControl, defaultILive } from './a432.i.live.ts';
-import { A432Spirit, A432_SPIRIT_CONSTANTS, spiritHarmonization, spiritAnalysis, spiritControl, defaultSpirit } from './a432.spirit.ts';
+import { A432Eye } from './a432.eye.ts';
+import { A432EyeSeeAll } from './a432.eye.see.all.ts';
+import { A432IImagine } from './a432.i.imagine.ts';
+import { A432ILive } from './a432.i.live.ts';
+import { A432Spirit } from './a432.spirit.ts';
 import { A432_TRINITY } from './a432.core.ts';
 
 // Add core exports for encryption and harmonics

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

@@ -9,10 +9,10 @@ import { matrixEmitter, startSelfEvolution } from './a432.self.ts';
 import { breathEmitter, startBreathing } from './a432.breathe.ts';
 import { pulseEmitter } from './a432.i.pulse.ts';
 import { clickEmitter } from './a432.i.click.ts';
-import { challengeCMYK } from './a432.challenge.ts';
+import './a432.challenge.ts';
 import { digitAngleToCMYK, asAngle, xorDigit } from './a432.math.ts';
 import type { CMYK } from './a432.cmyk.ts';
-import { type Digit } from './a432.types.ts';
+import './a432.types.ts';
 import { playDigit } from './a432.sound.ts';
 import { flashColor } from './a432.video.ts';
 import './a432.bus.auto.ts';
@@ -43,10 +43,10 @@ import { overlayRegistry } from './a432.ui.registry.ts';
 import { createUIButton } from './a432.ui.controls.ts';
 import { runGuidedJourney } from './a432.ui.journey.ts';
 import { registerUIEvent } from './a432.ui.events.ts';
-import { getState, setState, subscribe } from './a432.ui.state.ts';
-import { renderBlockchainStream } from './a432.ui.stream.ts';
+import { setState, subscribe } from './a432.ui.state.ts';
+import './a432.ui.stream.ts';
 import { renderAnalyticsDashboard } from './a432.ui.analytics.ts';
-import { startSession, endSession, logSessionEvent, getSessionHistory, exportSession } from './a432.ui.session.ts';
+import { getSessionHistory, exportSession } from './a432.ui.session.ts';
 import { startGateWay, type GateWayStep } from './a432.gate.way.ts';
 import { getLivingPiOverlayData } from './a432.pi.ts';
 import { getWaveParticleCMYKOverlayData, logWaveParticleEvent } from './a432.wave.particle.duality.ts';

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

@@ -81,7 +81,7 @@ export class A432Math {
     const x = c * (1 - abs((hue * 6) % 2 - 1));
     const m = light - c / 2;
     
-    let r = 0, g = 0, b = 0;
+    let r: number, g: number, b: number;
     if (hue < 1/6) { r = c; g = x; b = 0; }
     else if (hue < 2/6) { r = x; g = c; b = 0; }
     else if (hue < 3/6) { r = 0; g = c; b = x; }

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

@@ -12,14 +12,7 @@
 
 import { PI, cos, sin } from './a432.algebra.ts'
 import * as THREE from 'three';
-import { 
-  RODIN_SEQUENCE, 
-  TRINITY_AXIS, 
-  digitalRoot, 
-  angleForDigit,
-  frequencyForDigit,
-  hueForDigit 
-} from './a432.math.ts';
+import { RODIN_SEQUENCE, TRINITY_AXIS, digitalRoot, frequencyForDigit, hueForDigit } from './a432.math.ts';
 import { A432_RESOLVED_FRACTIONS } from './a432.resolved.ts';
 import { fractionToDecimal } from './a432.math.ts';
 // Analog signal values: exact integer ratios, collapsed to float only here

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

@@ -11,13 +11,7 @@
  * - The sequence creates a living sound vortex that harmonizes with consciousness
  */
 
-import { 
-  RODIN_SEQUENCE, 
-  TRINITY_AXIS, 
-  digitalRoot, 
-  frequencyForDigit,
-  angleForDigit 
-} from './a432.math.ts';
+import { RODIN_SEQUENCE, TRINITY_AXIS, digitalRoot, frequencyForDigit } from './a432.math.ts';
 
 // --- Canonical VBM Audio Constants ---
 const VBM_SEQUENCE = [0, ...TRINITY_AXIS, ...RODIN_SEQUENCE] as const;

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

@@ -12,14 +12,7 @@
  */
 
 import { abs, floor, pow, round } from './a432.algebra.ts'
-import { 
-  RODIN_SEQUENCE, 
-  TRINITY_AXIS, 
-  digitalRoot, 
-  angleForDigit,
-  frequencyForDigit,
-  hueForDigit 
-} from './a432.math.ts';
+import { digitalRoot, angleForDigit, frequencyForDigit, hueForDigit } from './a432.math.ts';
 
 // --- Canonical VBM Decode Constants ---
 const VBM_DECODE_SEQUENCE = "003691248751";
@@ -65,7 +58,7 @@ interface VBMHarmonic {
 // --- Canonical VBM Division Logic ---
 function calculateVBMDivision(index: number, digit: number): VBMDivision {
   // The bigger number is the accumulated value from previous divisions
-  let biggerNumber = 0;
+  let biggerNumber: number;
   
   // Calculate bigger number based on position and previous divisions
   if (index === 0) {
@@ -164,7 +157,7 @@ function generateVBMColor(digit: number): string {
   const x = c * (1 - abs((h * 6) % 2 - 1));
   const m = v - c;
   
-  let r = 0, g = 0, b = 0;
+  let r: number, g: number, b: number;
   
   if (h < 1/6) [r, g, b] = [c, x, 0];
   else if (h < 2/6) [r, g, b] = [x, c, 0];

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

@@ -12,14 +12,7 @@
  */
 
 import { abs, max, min, round } from './a432.algebra.ts'
-import { 
-  RODIN_SEQUENCE, 
-  TRINITY_AXIS, 
-  digitalRoot, 
-  angleForDigit,
-  frequencyForDigit,
-  hueForDigit 
-} from './a432.math.ts';
+import { RODIN_SEQUENCE, TRINITY_AXIS, digitalRoot, angleForDigit, frequencyForDigit, hueForDigit } from './a432.math.ts';
 
 // --- Canonical VBM Path Constants ---
 const VBM_PATH_SEPARATORS = {
@@ -120,7 +113,7 @@ function generateVBMColor(digit: number): string {
   const x = c * (1 - abs((h * 6) % 2 - 1));
   const m = v - c;
   
-  let r = 0, g = 0, b = 0;
+  let r: number, g: number, b: number;
   
   if (h < 1/6) [r, g, b] = [c, x, 0];
   else if (h < 2/6) [r, g, b] = [x, c, 0];

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

@@ -12,13 +12,7 @@
  */
 
 import { PI, abs, cos, min, round, sin } from './a432.algebra.ts'
-import { 
-  RODIN_SEQUENCE, 
-  TRINITY_AXIS, 
-  digitalRoot, 
-  hueForDigit,
-  angleForDigit 
-} from './a432.math.ts';
+import { RODIN_SEQUENCE, TRINITY_AXIS, digitalRoot, hueForDigit } from './a432.math.ts';
 
 // --- Canonical VBM Visualization Constants ---
 const VBM_SEQUENCE = [0, ...TRINITY_AXIS, ...RODIN_SEQUENCE] as const;
@@ -60,7 +54,7 @@ function generateVBMColor(digit: number): string {
   const x = c * (1 - abs((h * 6) % 2 - 1));
   const m = v - c;
   
-  let r = 0, g = 0, b = 0;
+  let r: number, g: number, b: number;
   
   if (h < 1/6) [r, g, b] = [c, x, 0];
   else if (h < 2/6) [r, g, b] = [x, c, 0];

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

@@ -8,12 +8,7 @@
  */
 
 import { PI, abs, cos, max, min, round, sin } from './a432.algebra.ts'
-import { 
-  A432_CONSTANTS,
-  calculateA432Consciousness,
-  calculateA432DimensionalState,
-  calculateA432Frequency,
-} from './a432.ts';
+import { calculateA432Consciousness, calculateA432DimensionalState, calculateA432Frequency } from './a432.ts';
 
 import { RODIN_SEQUENCE } from './a432.math.ts';
 import { calculateDigitalRoot } from './a432.ts';

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

@@ -1,4 +1,4 @@
-import { log } from './a432.algebra.ts'
+import './a432.algebra.ts'
 // a432.vortex.ts
 // Canonical, harmonized, recursive, self-aware vortex stream for the A432 system
 // Supports any number of dimensions (children, parent, meta, fold, map, observe, dimension-aware traversal)

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

@@ -5,16 +5,7 @@
  */
 
 import { abs, log2, round } from './a432.algebra.ts'
-import { 
-  GOLDEN_RATIO, 
-  PI, 
-  TAU, 
-  FIBONACCI_SEQUENCE,
-  calculateDigitalRoot,
-  A432_BASE_FREQUENCY,
-  A432_TRINITY_MULTIPLIER,
-  A432_VORTEX_MULTIPLIER
-} from './a432.math.constants.ts';
+import { GOLDEN_RATIO, TAU, FIBONACCI_SEQUENCE, calculateDigitalRoot, A432_BASE_FREQUENCY, A432_VORTEX_MULTIPLIER } from './a432.math.constants.ts';
 
 // === WAVE ENERGY INTERFACES ===
 export interface WavePattern {

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

@@ -5,7 +5,7 @@
  * Exports: proof, metaphysical meaning, analytic overlay, and blockchain event logger.
  */
 
-import { A432_SEQUENCE, digitAngleToCMYK, cmykToCss } from './a432.math.ts';
+import { digitAngleToCMYK, cmykToCss } from './a432.math.ts';
 
 /**
  * Canonical proof: In A432, wave and particle are two states of the same harmonic stream.

package/src/kernel/import-graph.ts

@@ -9,17 +9,9 @@
  */
 
 import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { join, relative, resolve, dirname, extname } from 'node:path'
+import { join, relative, resolve, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import {
-  computeVortexInvariantsHold,
-  computesGate,
-  foldPair,
-  memoByRoot,
-  merge,
-  merkleFold,
-  toUuid,
-} from '../0/index.ts'
+import { computeVortexInvariantsHold, computesGate, foldPair, memoByRoot, merge, merkleFold, toUuid } from '../0/index.ts'
 import { computeContentUuid } from '../integrity/content-uuid.ts'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))

package/src/quantum/adaptive.ts

@@ -6,8 +6,8 @@
  */
 
 import { round, max } from '../0/algebra.ts'
-import { type Register } from './simulator.ts'
-import { type OptimizationHistory, type VQEResult } from './variational-optimizer.ts'
+import './simulator.ts'
+import { type VQEResult } from './variational-optimizer.ts'
 import { type CompiledCircuit, type HardwareProfile } from './hardware-compilation.ts'
 
 export interface AdaptiveState {

package/src/quantum/advanced.ts

@@ -4,22 +4,9 @@
  * All integer-fraction decimals; no ambient Math.*.
  */
 
-import { PI, sqrt, round, abs, min, max } from '../0/algebra.ts'
-import {
-  type Register,
-  type Gate1,
-  zeroState,
-  applyGate1,
-  probabilities,
-  cnot,
-  cz,
-  measure,
-  H,
-  X,
-  Z,
-  rz,
-} from './simulator.ts'
-import { iqft } from './algorithms.ts'
+import { PI, sqrt, abs, min, max } from '../0/algebra.ts'
+import { type Gate1, zeroState, applyGate1, X } from './simulator.ts'
+import './algorithms.ts'
 
 // ── Quantum Amplitude Estimation (generalizes Grover) ──────────────────────
 /**

package/src/quantum/applications.ts

@@ -10,10 +10,10 @@
  * hybrid orchestration → dynamic mesh discovery → verified solution.
  */
 
-import { sqrt, abs, floor, max, min, round } from '../0/algebra.ts'
+import { sqrt, floor, max, min } from '../0/algebra.ts'
 import { estimateGroundStateEnergy, H2_HAMILTONIAN, ISING_MODEL, solveHybrid } from './hybrid.ts'
 import { AdaptiveOptimizer } from './adaptive.ts'
-import { initializeMesh, clusterMesh, extractPatterns, recommendExploration } from './comparison-mesh.ts'
+import { initializeMesh, clusterMesh, extractPatterns } from './comparison-mesh.ts'
 
 // ============================================================================
 // APPLICATION 1: Integer Factorization (Shor's Algorithm)

package/src/quantum/comparison-mesh.ts

@@ -8,7 +8,7 @@
  * Principle: solutions teach each other via topology. Mesh is the teacher.
  */
 
-import { sqrt, abs, floor, max, min, round } from '../0/algebra.ts'
+import { sqrt, abs, max, min } from '../0/algebra.ts'
 
 export interface MeshNode {
   readonly id: number

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'
 
 // ============================================================================