English

Domain 'anticeil.pages.dev' uses the developer-focused generic top-level domain (.dev) and includes subdomain 'anticeil'. Its registrable label 'pages' stretches across 5 characters with two vowels and three consonants. Breaking it apart gives 1 word: pages. No strong language cues emerged from the frequency lists.

html/d2/9b/d29b90a3-a4b0-4f89-9ebf-de8ae65e2a13.html.gz

8ac92fbb998cf84a1608d379f5981fd75f3b356f81134b300d7734a395640e26

924e4fcdfdf69acccff3d024d6e1ad3f41ca858d27fc4dd59fc4927dd933e7db

fc4015deb9127e073400d664da657da0bf084b694f5e6cf07962466a50ed2b06

3254fb179700136dce35e5bdc55cb46cd351fe5448687e43eadaed4dd4914eaa

a8b111071bb3b123c302e6182c01d6b3550f93a4b627398b07c46875d84090bb

b204e2f3d7fb21a1f168a44dce01cf8a9fdae4994c3586876fc750876fa6634d

7df707d0b7fcf0818490619c986d35907dfcb1baa037f330dfa4a2d94a293076

736f8a6966bf942a844b4718e2aa8d0cd1912583009f0d06519bba3b690fccd5

viewport

Anticeil - Command Center Architecture for Next-Gen Neural Bridge.

description

mobile-web-app-capable

apple-mobile-web-app-status-bar-style

apple-mobile-web-app-title

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET


    // --- CONSOLE NOISE SILENCER (AGGRESSIVE) ---
    // Suppresses 3rd party extension/environmental "noise" to keep the console clean for Anticeil development.
    (function() {
      const originalError = console.error;
      const originalWarn = console.warn;
      const originalLog = console.log;
      const originalInfo = console.info;
      
      const noisePatterns = [
        'ses ', 'intrinsics', 'react error #418', 'spatial-tracking',
        'private access token', 'sandboxed', 'favicon.ico', 'serviceworker',
        'cloudflare', 'blocked script', 'audio/mp4', 'video/webm', 'codecs=',
        'preload', 'policy violation', 'about:blank'
      ];

      const isNoise = (args) => {
        try {
          const msg = (Array.isArray(args) ? args : [args]).map(arg => {
            if (arg instanceof Error) return arg.toString() + ' ' + arg.stack;
            return String(arg);
          }).join(' ').toLowerCase();
          return noisePatterns.some(pattern => msg.includes(pattern.toLowerCase()));
        } catch (e) { return false; }
      };

      // Proxy console methods
      console.error = function(...args) { if (!isNoise(args)) originalError.apply(console, args); };
      console.warn = function(...args) { if (!isNoise(args)) originalWarn.apply(console, args); };
      console.log = function(...args) { if (!isNoise(args)) originalLog.apply(console, args); };
      console.info = function(...args) { if (!isNoise(args)) originalInfo.apply(console, args); };

      // Trap Uncaught Exceptions (e.g. MetaMask's Minified React Error)
      window.addEventListener('error', function(event) {
        if (event.message && isNoise([event.message, event.error])) {
          event.preventDefault(); // Prevents the browser from logging the error
          event.stopImmediatePropagation();
        }
      }, true);

      // Trap Unhandled Promises
      window.addEventListener('unhandledrejection', function(event) {
        if (event.reason && isNoise([event.reason.message || event.reason])) {
          event.preventDefault();
          event.stopImmediatePropagation();
        }
      }, true);
    })();
  


    // Defensive patch for Flutter Web Performance API crash
    // Prevents "SyntaxError: Failed to execute 'measure' on 'Performance': The mark ... does not exist"
    if (window.performance && window.performance.measure) {
      const originalMeasure = window.performance.measure;
      window.performance.measure = function (name, startMark, endMark) {
        try {
          return originalMeasure.call(window.performance, name, startMark, endMark);
        } catch (e) {
          // Ignore missing mark errors which are common in some Flutter Web versions
          if (e instanceof SyntaxError && e.message.includes('mark')) {
            console.warn('[Performance] Intercepted missing mark error:', e.message);
            return;
          }
          throw e;
        }
      };
    }

    // Intercept fetch to rewrite ONNX model URLs for flutter_onnxruntime
    // Because flutter_onnxruntime passes "packages/..." directly to ORT, which 404s on web.
    // Flutter web actually hosts package assets at "assets/packages/..."
    const originalFetch = window.fetch;
    window.fetch = function () {
      if (typeof arguments[0] === 'string' && arguments[0].startsWith('packages/')) {
        arguments[0] = 'assets/' + arguments[0];
      }
      return originalFetch.apply(this, arguments);
    };

  


    // 1. Force unregister generic service workers on every reload, EXCEPT for the COOP/COEP worker
    if ('serviceWorker' in navigator) {
      navigator.serviceWorker.getRegistrations().then(function (registrations) {
        for (let registration of registrations) {
          // Don't unregister our security header worker
          if (registration.active && registration.active.scriptURL.includes('coi-serviceworker')) {
            continue;
          }
          registration.unregister();
          console.log('[Worker] Stale ServiceWorker unlisted.');
        }
      });
    }

    // 2. _dismissHtmlOverlay is called by Dart from postFrameCallback, meaning
    //    Flutter has genuinely rendered its first frame before the overlay hides.
    //    This eliminates the black flash caused by the old MutationObserver
    //    approach (which fired when flt-glass-pane was added, before the canvas
    //    had any painted content).
    var _overlayDismissed = false;
    window._dismissHtmlOverlay = function () {
      if (_overlayDismissed) return;
      _overlayDismissed = true;
      var overlay = document.getElementById('loading-overlay');
      if (!overlay) return;
      console.log('[Splash] Dart first-frame signal received. Hiding overlay.');
      overlay.classList.add('hidden');
      setTimeout(function () {
        if (overlay && overlay.parentNode) overlay.remove();
      }, 350);
    };    // 3. NO FALLBACKS: We now strictly wait for Dart to signal readiness.
    //    This prevents the flicker caused by the overlay hiding before fonts
    //    are fully loaded in the background.
    window.addEventListener('load', function () {
      // Check isolation status
      console.log('🧪 [ISOLATION] Status: ' + (window.crossOriginIsolated ? 'ISOLATED' : 'NOT ISOLATED'));
    });
  


    // ═══════════════════════════════════════════════════════════════
    // OFFSCREEN CANVAS RECORDER
    // Records only the design canvas (not the entire Flutter UI)
    // Frames are sent from Dart via sendFrameToRecorder()
    // ═══════════════════════════════════════════════════════════════

    let _offscreenCanvas = null;
    let _offscreenCtx = null;
    let _mp4Muxer = null;
    let _mp4VideoEncoder = null;
    let _mp4AudioEncoder = null;
    let _mp4FrameIndex = 0;
    let _mp4Fps = 30;
    let _mp4Mode = false;
    let _pendingFrames = 0;
    let _onAllFramesProcessed = null;

    let _audioElements = [];
    let _audioContext = new (window.AudioContext || window.webkitAudioContext)();
    let _decodedAudios = {}; // url -> AudioBuffer

    let _mediaRecorder = null;
    let _mediaStream = null;
    let _mediaChunks = [];

    let _currentFormat = 'mp4';
    let _gifEncoder = null;

    /**
     * initOffscreenRecorder(width, height, fps, format, audioJson)
     */
    window.initOffscreenRecorder = function(width, height, fps, format, audioJson) {
      _currentFormat = format;
      _audioElements = (audioJson ? JSON.parse(audioJson) : []).filter(el => !el.isMuted);
      console.log('🎬 [RECORDER] Init V3: ' + width + 'x' + height + ' @ ' + fps + 'fps, format=' + format + ', audios=' + _audioElements.length);

      const encWidth = Math.round(width / 2) * 2;
      const encHeight = Math.round(height / 2) * 2;

      _offscreenCanvas = document.createElement('canvas');
      _offscreenCanvas.width = encWidth;
      _offscreenCanvas.height = encHeight;
      _offscreenCtx = _offscreenCanvas.getContext('2d', { alpha: false });
      
      _mp4FrameIndex = 0;
      _mp4Fps = fps;
      _mp4Mode = false;
      _pendingFrames = 0;
      _mediaChunks = [];
      _onAllFramesProcessed = null;

      // Prefetch audios immediately
      _audioElements.forEach(el => {
        if (!_decodedAudios[el.url]) {
          fetch(el.url)
            .then(r => r.arrayBuffer())
            .then(buf => _audioContext.decodeAudioData(buf))
            .then(decoded => {
              _decodedAudios[el.url] = decoded;
              console.log('🎬 [RECORDER] Audio Decoded: ' + el.url);
            })
            .catch(err => console.error('🎬 [RECORDER] Audio fail: ' + el.url, err));
        }
      });

      if (format === 'gif') {
        _gifEncoder = new GIF({
          workers: 2,
          quality: 10,
          width: encWidth,
          height: encHeight,
          workerScript: 'gif.worker.js'
        });
        return true;
      }

      // MP4 Path: Mp4Muxer + WebCodecs
      if ((format === 'mp4' || format === 'mov') && typeof Mp4Muxer !== 'undefined' && typeof VideoEncoder !== 'undefined') {
        try {
          _mp4Muxer = new Mp4Muxer.Muxer({
            target: new Mp4Muxer.ArrayBufferTarget(),
            video: {
              codec: 'avc',
              width: encWidth,
              height: encHeight,
            },
            audio: _audioElements.length > 0 ? {
              codec: 'aac',
              sampleRate: _audioContext.sampleRate,
              numberOfChannels: 2
            } : undefined,
            fastStart: 'in-memory',
          });

          _mp4VideoEncoder = new VideoEncoder({
            output: (chunk, meta) => _mp4Muxer.addVideoChunk(chunk, meta),
            error: e => console.error('🎬 [MP4 VIDEO ERROR]', e),
          });

          _mp4VideoEncoder.configure({
            codec: (format === 'mov') ? 'avc1.640028' : 'avc1.4D402A',
            width: encWidth,
            height: encHeight,
            bitrate: (format === 'mov') ? 16_000_000 : 8_000_000,
            framerate: fps,
          });

          if (_audioElements.length > 0) {
            _mp4AudioEncoder = new AudioEncoder({
              output: (chunk, meta) => _mp4Muxer.addAudioChunk(chunk, meta),
              error: e => console.error('🎬 [MP4 AUDIO ERROR]', e),
            });
            _mp4AudioEncoder.configure({
              codec: 'mp4a.40.2', // AAC-LC
              numberOfChannels: 2,
              sampleRate: _audioContext.sampleRate,
              bitrate: 128000,
            });
          }

          _mp4Mode = true;
        } catch (err) {
          console.error('🎬 [RECORDER] MP4-V3 Init Failed:', err);
          _mp4Mode = false;
        }
      }
      
      return true;
    };

    /**
     * sendFrameToRecorder(imageBytes)
     */
    window.sendFrameToRecorder = function(imageBytes) {
      if (!_offscreenCanvas || !_offscreenCtx) return;
      _pendingFrames++;
      const blob = new Blob([imageBytes], { type: 'image/png' });
      const url = URL.createObjectURL(blob);
      const img = new Image();
      img.onload = () => {
        if (!_offscreenCanvas || !_offscreenCtx) {
          URL.revokeObjectURL(url);
          _pendingFrames--;
          return;
        }
        _offscreenCtx.drawImage(img, 0, 0, _offscreenCanvas.width, _offscreenCanvas.height);
        URL.revokeObjectURL(url);

        if (_currentFormat === 'gif' && _gifEncoder) {
           _gifEncoder.addFrame(_offscreenCtx, { copy: true, delay: Math.round(1000 / _mp4Fps) });
        }

        if (_mp4Mode && _mp4VideoEncoder && _mp4VideoEncoder.state === 'configured') {
          const frame = new VideoFrame(_offscreenCanvas, {
            timestamp: Math.round((_mp4FrameIndex / _mp4Fps) * 1_000_000),
            duration: Math.round((1 / _mp4Fps) * 1_000_000),
          });
          _mp4VideoEncoder.encode(frame, { keyFrame: (_mp4FrameIndex % (_mp4Fps * 2) === 0) });
          frame.close();
          _mp4FrameIndex++;
        }

        _pendingFrames--;
        if (_pendingFrames === 0 && _onAllFramesProcessed) _onAllFramesProcessed();
      };
      img.src = url;
    };

    /**
     * finalizeRecording(filename)
     */
    window.finalizeRecording = function(filename) {
      return new Promise(async (resolve) => {
        if (_pendingFrames > 0) {
          await new Promise(r => { _onAllFramesProcessed = r; });
        }

        if (_currentFormat === 'gif' && _gifEncoder) {
          _gifEncoder.on('finished', blob => {
            const url = URL.createObjectURL(blob);
            _triggerDownload(url, filename || 'anticeil.gif');
            _cleanup();
            resolve({ url, size: blob.size, type: 'image/gif' });
          });
          _gifEncoder.render();
          return;
        }

        if (_mp4Mode && _mp4VideoEncoder && _mp4Muxer) {
          try {
            await _mp4VideoEncoder.flush();
            _mp4VideoEncoder.close();

            // ── AUDIO MIXING & ENCODING ──
            if (_mp4AudioEncoder && _audioElements.length > 0) {
              const totalDuration = _mp4FrameIndex / _mp4Fps;
              console.log('🎬 [RECORDER] Mixing Audio, Duration: ' + totalDuration);

              // Wait if some audios still decoding
              for (const el of _audioElements) {
                while (!_decodedAudios[el.url]) await new Promise(r => setTimeout(r, 100));
              }

              const sampleRate = _audioContext.sampleRate;
              const offlineCtx = new OfflineAudioContext(2, Math.ceil(sampleRate * Math.max(0.1, totalDuration)), sampleRate);
              _audioElements.forEach(el => {
                const buffer = _decodedAudios[el.url];
                if (buffer) {
                  const source = offlineCtx.createBufferSource();
                  source.buffer = buffer;
                  source.connect(offlineCtx.destination);
                  const offset = el.sourceStartTime || 0;
                  source.start(el.startTime, offset, el.duration);
                  source.stop(el.startTime + el.duration);
                }
              });

              const mixedBuffer = await offlineCtx.startRendering();
              const samples = mixedBuffer.length;
              const channels = 2;

              // Feed mixed audio into AudioEncoder in chunks
              const CHUNK_SIZE = 4096;
              for (let i = 0; i < samples; i += CHUNK_SIZE) {
                const count = Math.min(CHUNK_SIZE, samples - i);
                const data = new Float32Array(count * channels);
                for (let ch = 0; ch < channels; ch++) {
                  const chanData = mixedBuffer.getChannelData(ch);
                  const planeOffset = ch * count;
                  for (let s = 0; s < count; s++) {
                    data[planeOffset + s] = chanData[i + s];
                  }
                }
                const audioData = new AudioData({
                  format: 'f32-planar',
                  sampleRate: sampleRate,
                  numberOfChannels: channels,
                  numberOfFrames: count,
                  timestamp: Math.round((i / sampleRate) * 1_000_000),
                  data: data,
                });
                _mp4AudioEncoder.encode(audioData);
              }
              await _mp4AudioEncoder.flush();
              _mp4AudioEncoder.close();
            }

            _mp4Muxer.finalize();
            const { buffer } = _mp4Muxer.target;
            const blob = new Blob([buffer], { type: 'video/mp4' });
            const url = URL.createObjectURL(blob);
            _triggerDownload(url, filename || 'anticeil.mp4');
            _cleanup();
            resolve({ url, size: blob.size, type: 'video/mp4' });
            return;
          } catch (err) {
            console.error('🎬 [RECORDER] MP4 Render fail:', err);
          }
        }
        resolve(null);
      });
    };

    window.abortJsRecording = function() {
      console.log('🎬 [RECORDER] ABORTED by user.');
      _cleanup();
    };

    /**
     * captureVideoFrame(video)
     * Captures current frame of a video element to a PNG data URL
     */
    window.captureVideoFrame = function(video) {
        if (!video || video.readyState < 2) return null;
        const canvas = document.createElement('canvas');
        canvas.width = video.videoWidth;
        canvas.height = video.videoHeight;
        const ctx = canvas.getContext('2d');
        ctx.drawImage(video, 0, 0);
        return canvas.toDataURL('image/png');
    };

    function _triggerDownload(url, name) {
      const a = document.createElement('a');
      a.href = url;
      a.download = name;
      document.body.appendChild(a);
      a.click();
      a.remove();
      console.log('🎬 [RECORDER] Download triggered: ' + name);
    }

    function _cleanup() {
      if (_mediaStream) _mediaStream.getTracks().forEach(t => t.stop());
      _mp4Muxer = null;
      _mp4VideoEncoder = null;
      _mp4AudioEncoder = null;
      _mediaRecorder = null;
      _offscreenCanvas = null;
      _gifEncoder = null;
    }
  

jsDelivr

Anticeil

✅ Low Risk - http://anticeil.pages.dev/

Requests	IP Address	Location	AS Autonomous System
6	172.66.47.88	United States	AS13335Cloudflare, Inc.
4	192.178.183.94	United States	AS13335
4	142.251.14.94	United States	Unknown
4	151.101.1.229	United States	Unknown
4	104.18.94.41	United States	AS13335Cloudflare, Inc.
4	142.250.154.95	United States	AS15169Google LLC
26	6	-	-

Security Scan Report: anticeil.pages.dev

Summary

AI Security Verdict

Low Risk

Risk Factors

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies1

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History