@needle-tools/engine 4.15.0-next.f391a30 → 4.15.0

package/plugins/vite/index.js

@@ -1,6 +1,3 @@
-import { needleAI } from "./ai.js";
-export { needleAI } from "./ai.js";
-
 import { needleAsap } from "./asap.js";
 export { needleAsap } from "./asap.js";
 
@@ -46,8 +43,8 @@ export { needleTransformCodegen } from "./transform-codegen.js";
 import { needleLicense } from "./license.js";
 export { needleLicense } from "./license.js";
 
-import { needleMakeFilesLocal, needleLocalFilesSceneAnalysis } from "./local-files.js";
-export { needleMakeFilesLocal, needleLocalFilesSceneAnalysis } from "./local-files.js";
+import { needleMakeFilesLocal } from "./local-files.js";
+export { needleMakeFilesLocal } from "./local-files.js";
 
 import { needlePeerjs } from "./peer.js";
 export { needlePeerjs } from "./peer.js";
@@ -122,7 +119,6 @@ export const needlePlugins = async (command, config = undefined, userSettings =
     userSettings = { ...defaultUserSettings, ...userSettings };
 
     const array = [
-        needleAI(command, config, userSettings),
         needleLogger(command, config, userSettings),
         needleDefines(command, config, userSettings),
         needleLicense(command, config, userSettings),
@@ -131,7 +127,6 @@ export const needlePlugins = async (command, config = undefined, userSettings =
         needleMeta(command, config, userSettings),
         needlePoster(command, config, userSettings),
         needleReload(command, config, userSettings),
-        needleLocalFilesSceneAnalysis(command, config, userSettings),
         needleMakeFilesLocal(command, config, userSettings),
         needleBuild(command, config, userSettings),
         needleBuildInfo(command, config, userSettings),
@@ -140,6 +135,7 @@ export const needlePlugins = async (command, config = undefined, userSettings =
         needleTransformCode(command, config, userSettings),
         needleDrop(command, config, userSettings),
         needlePeerjs(command, config, userSettings),
+        needleDependencyWatcher(command, config, userSettings),
         needleDependencies(command, config, userSettings),
         vite_4_4_hack(command, config, userSettings),
         needleFacebookInstantGames(command, config, userSettings),
@@ -156,6 +152,5 @@ export const needlePlugins = async (command, config = undefined, userSettings =
     if(asap) array.push(asap);
 
     array.push(await editorConnection(command, config, userSettings, array));
-    array.push(needleDependencyWatcher(command, config, userSettings));
     return array;
 }

package/plugins/vite/local-files.js

@@ -1,2 +1,441 @@
-export { needleMakeFilesLocal, makeFilesLocalIsEnabled } from './local-files-core.js';
-export { needleLocalFilesSceneAnalysis } from './local-files-analysis.js';
+import https from 'https';
+import { createHash } from 'crypto';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { start } from 'repl';
+
+/** 
+ * @typedef {{pluginContext:import('rollup').TransformPluginContext, cache:Cache, command:string, viteConfig:import("vite").ResolvedConfig | null}} Context
+ */
+
+const debug = false;
+
+/**
+ * Checks if the local files plugin is enabled in user settings.
+ * @param {import('../types/userconfig.js').userSettings} userSettings - The user settings object
+ */
+export const makeFilesLocalIsEnabled = (userSettings) => {
+    if (typeof userSettings?.makeFilesLocal === "object") return userSettings?.makeFilesLocal?.enabled === true;
+    return userSettings?.makeFilesLocal === true;
+}
+
+/**
+ * Download files and rewrite code
+ * @param {string} command - The command that is being run
+ * @param {object} config - The config object
+ * @param {import('../types/userconfig.js').userSettings} userSettings
+ * @returns {import('vite').Plugin | null}
+ */
+export const needleMakeFilesLocal = (command, config, userSettings) => {
+
+    if (!makeFilesLocalIsEnabled(userSettings)) {
+        return null;
+    }
+
+    console.log(`[needle:local-files] Local files plugin is enabled`);
+
+    const cache = new Cache();
+
+    /** @type {import("vite").ResolvedConfig | null} */
+    let viteConfig = null;
+
+    /** @type {import("vite").Plugin} */
+    const plugin = {
+        name: "needle:local-files",
+        // enforce: 'pre', // explictly DON'T define enforce:pre because of svelte postcss compat
+        apply: "build",
+        configResolved(config) {
+            viteConfig = config;
+        },
+        // transform bundle
+        async transform(src, _id) {
+            src = await makeLocal(src, "ext/", "", {
+                pluginContext: this,
+                cache: cache,
+                command: command,
+                viteConfig: viteConfig,
+            });
+            return {
+                code: src,
+                map: null,
+            };
+        },
+        buildEnd() {
+            const map = cache.map;
+            console.log(""); // Make a new line for better readability
+            console.log(`[needle:local-files] Made ${map.size} files local:`);
+            for (const [key, value] of map.entries()) {
+                console.log(`- ${key} → ${value}`);
+            }
+        }
+    }
+    return plugin;
+}
+
+/**
+ * Rewrites the source code to make local files
+ * @param {string} src - The source code to rewrite
+ * @param {string} basePath - The base path where the files will be saved
+ * @param {string} currentDir - The current directory of the file being processed
+ * @param {Context} context - The Vite plugin context and command
+ */
+async function makeLocal(src, basePath, currentDir, context) {
+
+    const command = context.command;
+
+    if (debug) {
+        // Find all urls in the source code.
+        // Exclude URLs inside comments, like: 
+        // - // https://example.com
+        // - /* ... https://example.com ... */
+        // - @link https://example.com
+        // - * ... https://example.com
+        const urlRegexExcludingComments = /(?<!\/\/.*)(?<!\/\*.*)(?<!@link\s+)(["'])(https?:\/\/[^\s'"]+?)\1/g;
+        let match0;
+        while ((match0 = urlRegexExcludingComments.exec(src)) !== null) {
+            const url = match0[2];
+            if (debug) console.log(`\nFound URL: ${url} in ${currentDir}`);
+        }
+    }
+
+    // Google Fonts URLs
+    while (true) {
+        const match = /["'](https:\/\/fonts\.googleapis\.com\/.+?)["']/g.exec(src);
+        if (match === null) {
+            break;
+        }
+        const url = match[1];
+        if (debug) console.log(`\nFound google font URL: ${url}`);
+        // Check if the font URL is already in the cache
+        const cachedPath = context.cache.getFromCache(url);
+        if (cachedPath) {
+            if (debug) console.log(`Using cached font URL: ${cachedPath}`);
+            src = src.replace(url, cachedPath);
+            continue; // Skip downloading if already cached
+        }
+        let font = await downloadText(url);
+        const familyNameMatch = /family=([^&]+)/.exec(url);
+        const familyName = familyNameMatch ? getValidFilename(familyNameMatch[1], font) : (new URL(url).pathname.split('/').pop());
+        font = await makeLocal(font, basePath, basePath, context);
+        const fontFileName = `font-${familyName}.css`;
+        const outputPath = basePath + fontFileName;
+        let newPath;
+        if (command === 'build') {
+            const referenceId = context.pluginContext.emitFile({
+                type: 'asset',
+                fileName: outputPath,
+                source: font,
+            });
+            const localPath = `${context.pluginContext.getFileName(referenceId)}`;
+            newPath = getRelativeToBasePath(localPath, currentDir);
+            // ensureFileExists(localPath, font);
+        }
+        else {
+            // Create base64 URL for dev mode
+            const base64Font = Buffer.from(font).toString('base64');
+            newPath = `data:text/css;base64,${base64Font}`;
+        }
+        if (newPath) {
+            context.cache.addToCache(url, newPath);
+            src = src.replace(url, newPath);
+        }
+    }
+
+    // Google Fonts gstatic URLs
+    while (true) {
+        const match = /["'(](https:\/\/fonts\.gstatic\.com\/)(.+?)["')]/g.exec(src);
+        if (match === null) {
+            break;
+        }
+        const fontPath = match[2];
+        const url = match[1] + fontPath;
+        if (debug) console.log(`\nFound gstatic URL: ${url}`);
+        // Check if the font URL is already in the cache
+        const cachedPath = context.cache.getFromCache(url);
+        if (cachedPath) {
+            if (debug) console.log(`Using cached gstatic font URL: ${cachedPath}`);
+            src = src.replace(url, cachedPath);
+            continue; // Skip downloading if already cached
+        }
+        const font = await downloadBinary(url);
+        const filename = getValidFilename(fontPath, font);
+        if (debug) console.log(`Saving font to: ${basePath + filename}`);
+        let newPath;
+        if (command === 'build') {
+            const referenceId = context.pluginContext.emitFile({
+                type: 'asset',
+                fileName: basePath + filename,
+                source: font,
+            });
+            const localPath = `${context.pluginContext.getFileName(referenceId)}`;
+            newPath = getRelativeToBasePath(localPath, currentDir);
+            // ensureFileExists(localPath, font);
+        } else {
+            // Create base64 URL for dev mode
+            const base64Font = Buffer.from(font).toString('base64');
+            newPath = `data:text/css;base64,${base64Font}`;
+        }
+        context.cache.addToCache(url, newPath);
+        src = src.replace(url, newPath);
+    }
+
+    // Load QRCode.js
+    while (true) {
+        // https://cdn.jsdelivr.net/gh/davidshimjs/qrcodejs@gh-pages/qrcode.min.js
+        const match = /["'](https:\/\/cdn\.jsdelivr\.net\/gh\/davidshimjs\/qrcodejs@[^'"]+?\/qrcode\.min\.js)["']/g.exec(src);
+        if (match === null) {
+            break;
+        }
+        const url = match[1];
+        if (debug) console.log(`\nFound QR code URL: ${url}`);
+        // Check if the QR code URL is already in the cache
+        const cachedPath = context.cache.getFromCache(url);
+        if (cachedPath) {
+            if (debug) console.log(`Using cached QR code URL: ${cachedPath}`);
+            src = src.replace(url, cachedPath);
+            continue; // Skip downloading if already cached
+        }
+        const qrCode = await downloadBinary(url);
+        const filename = getValidFilename(url, qrCode);
+        if (debug) console.log(`Saving QR code to: ${basePath + filename}`);
+        let newPath;
+        if (command === 'build') {
+            const referenceId = context.pluginContext.emitFile({
+                type: 'asset',
+                fileName: basePath + filename,
+                source: qrCode,
+            });
+            const localPath = `${context.pluginContext.getFileName(referenceId)}`;
+            newPath = getRelativeToBasePath(localPath, currentDir);
+            // ensureFileExists(localPath, qrCode);
+        } else {
+            // create base64 URL for dev mode
+            const base64QrCode = Buffer.from(qrCode).toString('base64');
+            newPath = `data:application/javascript;base64,${base64QrCode}`;
+        }
+        context.cache.addToCache(url, newPath);
+        src = src.replace(url, newPath);
+    }
+
+    // Polyhaven.org URLs
+    let startIndex = 0;
+    while (true) {
+        const match = /["'](https:\/\/dl\.polyhaven\.org\/file\/.+?)["']/g.exec(src.slice(startIndex));
+        if (match === null) {
+            break;
+        }
+        startIndex += match.index + match[0].length; // Update startIndex to continue searching
+        const url = match[1];
+        if (url.endsWith("/")) {
+            if (debug) console.warn(`Skipping Polyhaven URL that ends with a slash: ${url}`);
+            continue; // Skip URLs that end with a slash
+        }
+        if (url.includes("\"") || url.includes("'")) {
+            if (debug) console.warn(`Skipping Polyhaven URL with quotes: ${url}`);
+            continue; // Skip URLs with quotes
+        }
+        if (debug) console.log(`\nFound Polyhaven URL: ${url}`);
+        // Check if the Polyhaven URL is already in the cache
+        const cachedPath = context.cache.getFromCache(url);
+        if (cachedPath) {
+            if (debug) console.log(`Using cached Polyhaven URL: ${cachedPath}`);
+            src = src.replace(url, cachedPath);
+            continue; // Skip downloading if already cached
+        }
+        const polyhavenFile = await downloadBinary(url);
+        const filename = getValidFilename(url, polyhavenFile);
+        if (debug) console.log(`Saving Polyhaven file to: ${basePath + filename}`);
+        let newPath;
+        if (command === 'build') {
+            const referenceId = context.pluginContext.emitFile({
+                type: 'asset',
+                fileName: basePath + filename,
+                source: polyhavenFile,
+            });
+            const localPath = `${context.pluginContext.getFileName(referenceId)}`;
+            newPath = getRelativeToBasePath(localPath, currentDir);
+            // ensureFileExists(localPath, polyhavenFile);
+        } else {
+            // Create base64 URL for dev mode
+            const base64PolyhavenFile = Buffer.from(polyhavenFile).toString('base64');
+            newPath = `data:application/octet-stream;base64,${base64PolyhavenFile}`;
+        }
+        if (newPath) {
+            context.cache.addToCache(url, newPath);
+            src = src.replace(url, newPath);
+        }
+    }
+
+    return src;
+
+    // /**
+    //  * Ensures that a file exists at the specified relative path with the given content.
+    //  * If the file does not exist, it will be created with the provided content.
+    //  * @param {string} relPath - The relative path to the file
+    //  * @param {string|Uint8Array} content - The content to write to the file
+    //  * @returns {void}
+    //  */
+    // function ensureFileExists(relPath, content) {
+    //     const outputPath = context.viteConfig?.build?.outDir || "dist";
+    //     const fullPath = resolve(outputPath, relPath);
+    //     if (!existsSync(fullPath)) {
+    //         if (debug) console.log(`Creating file: ${fullPath}`);
+    //         const dir = resolve(fullPath, '..');
+    //         mkdirSync(dir, { recursive: true });
+    //         writeFileSync(fullPath, content);
+    //     }
+    // }
+}
+
+
+class Cache {
+    __cache = new Map();
+    /**
+     * Adds a key-value pair to the cache.
+     * @param {string} key - The key to store the value under
+     * @param {string|Uint8Array} value - The value to store in the cache
+     * @returns {void}
+     */
+    addToCache(key, value) {
+        if (this.__cache.has(key)) {
+            if (debug) console.warn(`Key ${key} already exists in cache, overwriting.`);
+        }
+        this.__cache.set(key, value);
+    }
+    /**
+     * Retrieves a value from the cache by its key.
+     * @param {string} key - The key to look up in the cache
+     */
+    getFromCache(key) {
+        if (this.__cache.has(key)) {
+            return this.__cache.get(key);
+        } else {
+            return null;
+        }
+    }
+    get map() {
+        return this.__cache;
+    }
+}
+
+
+/**
+ * Returns a relative path based on the base path.
+ * @param {string} path - The path to check
+ * @param {string | undefined | null} basePath - The base path to compare against
+ * @return {string} - The relative path if it starts with the base path, otherwise the original path
+ */
+function getRelativeToBasePath(path, basePath) {
+    if (basePath?.length && path.startsWith(basePath)) {
+        return "./" + path.substring(basePath.length);
+    }
+    return path;
+}
+
+
+/**
+ * Generates a valid filename from a given path.
+ * @param {string} path - The path to generate a filename from
+ * @param {string|Uint8Array} content - The content to hash for uniqueness (not used in this example)
+ */
+function getValidFilename(path, content) {
+    if (path.startsWith("http:") || path.startsWith("https:")) {
+        const url = new URL(path);
+        const pathParts = url.pathname.split('/');
+        const filename = pathParts.pop() || 'file';
+        const nameParts = filename.split('.');
+        const nameWithoutExt = nameParts.slice(0, -1).join('.');
+        path = `${nameWithoutExt}-${createContentMd5(url.host + pathParts.join('/'))}.${nameParts.pop() || 'unknown'}`;
+    }
+
+    // Remove any characters that are not valid in filenames
+    let name = path.replace(/[^a-z0-9_\-\.\+]/gi, '-');
+
+    const maxLength = 200;
+    if (path.length > maxLength) {
+        // If the name is too long, hash it to create a unique identifier
+        const hash = createContentMd5(content);
+        let ext = "";
+        const extIndex = name.lastIndexOf('.');
+        if (extIndex !== -1) {
+            ext = name.substring(extIndex + 1);
+            name = name.substring(0, extIndex);
+        }
+        name = `${name.substring(0, maxLength)}-${hash}${ext ? `.${ext}` : ''}`;
+    }
+    return name;
+
+}
+
+/**
+ * Creates a hash of the content using MD5.
+ * @param {string|Uint8Array} str - The content to hash
+ */
+function createContentMd5(str) {
+    return createHash('md5')
+        .update(str)
+        .digest('hex');
+}
+
+
+/**
+ * @param {string} url - The URL of the font to download
+ */
+function downloadText(url) {
+    return new Promise(((res, rej) => {
+        https.get(url, (response) => {
+            if (response.statusCode !== 200) {
+                console.log();
+                console.error(`Failed to download (${response.statusCode}): ${url}`);
+                rej(new Error(`Failed to download (${response.statusCode}): ${url}`));
+                return;
+            }
+
+            console.log(""); // Make a new line for better readability
+            console.log(`[needle:local-files] Make local: ${url}`);
+
+            let data = '';
+            response.on('data', (chunk) => {
+                data += chunk;
+            });
+            response.on('end', () => {
+                // Here you can save the data to a file or process it as needed
+                if (debug) console.log(`Downloaded from ${url}`);
+                res(data);
+            });
+        });
+    }))
+}
+
+function downloadBinary(url) {
+    return new Promise((res, rej) => {
+        https.get(url, (response) => {
+
+            // Handle redirects
+            if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+                if (debug) console.log(`Redirecting to ${response.headers.location}`);
+                return downloadBinary(response.headers.location).then(res).catch(rej);
+            }
+
+            if (response.statusCode !== 200) {
+                console.log();
+                console.error(`Failed to download (${response.statusCode}): ${url}`);
+                rej(new Error(`Failed to download (${response.statusCode}): ${url}`));
+                return;
+            }
+
+            console.log(""); // Make a new line for better readability
+            console.log(`[needle:local-files] Make local: ${url}`);
+
+            const chunks = [];
+            response.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            response.on('end', () => {
+                // Here you can save the data to a file or process it as needed
+                if (debug) console.log(`Downloaded from ${url}`);
+                res(Buffer.concat(chunks));
+            });
+        });
+    });
+}

package/plugins/vite/logger.client.js

@@ -1,4 +1,3 @@
-// @ts-check
 import path from "path";
 
 let isStringifying = false;
@@ -7,7 +6,7 @@ let isStringifying = false;
  * Patches console methods to capture log messages and send them to the server.
  * This is useful for debugging and logging in the client.
  * @param {"log" | "warn" | "info" | "debug" | "error" | "internal"} level
- * @param {...unknown} message - The log message to capture.
+ * @param {any} message - The log message to capture.
  */
 function sendLogToServer(level, ...message) {
     if (isStringifying) return;
@@ -15,20 +14,20 @@ function sendLogToServer(level, ...message) {
         try {
             isStringifying = true;
             // console.time("sendLogToServer");
-            let msg = /** @type {string} */ (stringifyLog(message));
+            message = stringifyLog(message);
             // console.timeEnd("sendLogToServer");
             // keep messages below payload limit
-            if (msg.length > 100_000) {
-                msg = msg.slice(0, 100_000) + "... <truncated>";
+            if (message.length > 100_000) {
+                message = message.slice(0, 100_000) + "... <truncated>";
             }
             // @ts-ignore
-            import.meta.hot.send("needle:client-log", { level, message: msg });
-        } catch (/** @type {{ message?: string }} */ e) {
+            import.meta.hot.send("needle:client-log", { level, message: message });
+        } catch (e) {
             // silently fail but send a message
             try {
                 import.meta.hot.send("needle:client-log", { level: "error", message: `Error during logging: ${e.message}` });
             }
-            catch (/** @type {unknown} */ e2) {
+            catch (e2) {
                 // fallback failed as well
             }
         }
@@ -38,7 +37,6 @@ function sendLogToServer(level, ...message) {
     }
 }
 
-/** @param {(...args: unknown[]) => void} fn @param {unknown[]} args */
 function logHelper(fn, args) {
     const error = new Error();
     const stack = error.stack;
@@ -54,32 +52,32 @@ function logHelper(fn, args) {
 if (import.meta && "hot" in import.meta) {
 
     function patchLogs() {
-        const originalLog = /** @type {(...args: unknown[]) => void} */ (console.log.bind(console));
-        const originalWarn = /** @type {(...args: unknown[]) => void} */ (console.warn.bind(console));
-        const originalInfo = /** @type {(...args: unknown[]) => void} */ (console.info.bind(console));
-        const originalDebug = /** @type {(...args: unknown[]) => void} */ (console.debug.bind(console));
-        const originalError = /** @type {(...args: unknown[]) => void} */ (console.error.bind(console));
+        const originalLog = console.log.bind(console);
+        const originalWarn = console.warn.bind(console);
+        const originalInfo = console.info.bind(console);
+        const originalDebug = console.debug.bind(console);
+        const originalError = console.error.bind(console);
 
-        console.log = /** @type {(...args: unknown[]) => void} */ (function (...args) {
+        console.log = function (...args) {
             logHelper(originalLog, args);
             sendLogToServer("log", ...args);
-        })
-        console.warn = /** @type {(...args: unknown[]) => void} */ ((...args) => {
+        }
+        console.warn = (...args) => {
             logHelper(originalWarn, args);
             sendLogToServer("warn", ...args);
-        })
-        console.info = /** @type {(...args: unknown[]) => void} */ ((...args) => {
+        }
+        console.info = (...args) => {
             logHelper(originalInfo, args);
             sendLogToServer("info", ...args);
-        })
-        console.debug = /** @type {(...args: unknown[]) => void} */ ((...args) => {
+        }
+        console.debug = (...args) => {
             logHelper(originalDebug, args);
             sendLogToServer("debug", ...args);
-        })
-        console.error = /** @type {(...args: unknown[]) => void} */ ((...args) => {
+        }
+        console.error = (...args) => {
             logHelper(originalError, args);
             sendLogToServer("error", ...args);
-        })
+        }
         return () => {
             console.log = originalLog;
             console.warn = originalWarn;
@@ -127,12 +125,11 @@ Connection: ${"connection" in navigator ? JSON.stringify(navigator.connection) :
 User Activation: ${"userActivation" in navigator ? JSON.stringify(navigator.userActivation) : "Not available"}
 `);
 
-        /** @typedef {{ vendor?: string, architecture?: string, device?: string, description?: string, features?: unknown, limits?: unknown }} GPUAdapterInfoLike */
         if ("gpu" in navigator) {
             // @ts-ignore
             navigator.gpu.requestAdapter()
-                .then(/** @type {(adapter: {requestDevice(): Promise<{adapterInfo: GPUAdapterInfoLike}>}|null) => Promise<{adapterInfo: GPUAdapterInfoLike}>|null} */ (adapter) => adapter ? adapter.requestDevice() : null)
-                .then(/** @type {(device: {adapterInfo: GPUAdapterInfoLike}|null) => void} */ (device) => {
+                .then(adapter => adapter ? adapter.requestDevice() : null)
+                .then(device => {
                     if (device) {
                         const adapterInfo = device.adapterInfo;
                         if (adapterInfo) {
@@ -149,21 +146,17 @@ User Activation: ${"userActivation" in navigator ? JSON.stringify(navigator.user
                 });
         }
     }
-    catch (/** @type {{ message?: string }} */ e) {
+    catch (e) {
         // silently fail
         sendLogToServer("error", `Error during initial log: ${e.message}`);
     }
 
     window.addEventListener('error', (event) => {
-        const typedErrorEvent = /** @type {{ error: unknown, message: string }} */ (/** @type {unknown} */ (event));
-        const error = /** @type {{ stack?: string, message?: string } | null | undefined} */ (typedErrorEvent.error);
-        const errorMessage = error ? error.stack || error.message : typedErrorEvent.message;
+        const errorMessage = event.error ? event.error.stack || event.error.message : event.message;
         sendLogToServer("error", errorMessage);
     });
     window.addEventListener('unhandledrejection', (event) => {
-        const typedRejEvent = /** @type {{ reason: unknown }} */ (/** @type {unknown} */ (event));
-        const rejectionReason = /** @type {{ stack?: string, message?: string } | null | undefined} */ (typedRejEvent.reason);
-        const reason = rejectionReason ? rejectionReason.stack || rejectionReason.message : "Unhandled rejection without reason";
+        const reason = event.reason ? event.reason.stack || event.reason.message : "Unhandled rejection without reason";
         sendLogToServer("error", `Unhandled promise rejection: ${reason}`);
     });
     window.addEventListener('beforeunload', () => {
@@ -218,7 +211,7 @@ User Activation: ${"userActivation" in navigator ? JSON.stringify(navigator.user
         sendLogToServer("internal", `URL hash changed to ${location.hash}`);
     });
     window.addEventListener('popstate', () => {
-        sendLogToServer("internal", `History state changed: ${JSON.stringify(/** @type {{ state: unknown }} */ (history).state)}`);
+        sendLogToServer("internal", `History state changed: ${JSON.stringify(history.state)}`);
     });
 
 
@@ -234,10 +227,10 @@ User Activation: ${"userActivation" in navigator ? JSON.stringify(navigator.user
 
 /**
  * Stringifies a log message, handling circular references and formatting.
- * @param {unknown} log
- * @param {Set<unknown>} [seen]
+ * @param {any} log
+ * @param {Set<any>} [seen]
  */
-function stringifyLog(log, seen = /** @type {Set<unknown>} */ (new Set()), depth = 0) {
+function stringifyLog(log, seen = new Set(), depth = 0) {
     const isServer = typeof window === "undefined";
     const stringify_limits = {
         string: isServer ? 100_000 : 1_000,
@@ -279,9 +272,8 @@ function stringifyLog(log, seen = /** @type {Set<unknown>} */ (new Set()), depth
         || log instanceof BigUint64Array
         || log instanceof Float64Array
     ) {
-        const logArr = /** @type {ArrayLike<unknown>} */ (/** @type {unknown} */ (log));
-        seen.add(logArr);
-        return stringifyArray(logArr);
+        seen.add(log);
+        return stringifyArray(log);
     }
     if (typeof log === "object") {
 
@@ -295,12 +287,11 @@ function stringifyLog(log, seen = /** @type {Set<unknown>} */ (new Set()), depth
             return `<Error: ${log.message}\nStack: ${log.stack}>`;
         }
 
-        const logObj = /** @type {Record<string, unknown>} */ (log);
-        const keys = Object.keys(logObj);
+        const keys = Object.keys(log);
         let res = "{";
         for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
-            let value = logObj[key];
+            let value = log[key];
             if (i >= stringify_limits.object_keys) {
                 res += `, ... <truncated ${keys.length - i} keys>`;
                 break;
@@ -335,7 +326,6 @@ function stringifyLog(log, seen = /** @type {Set<unknown>} */ (new Set()), depth
 
     return String(log);
 
-    /** @param {ArrayLike<unknown>} arr @returns {string} */
     function stringifyArray(arr) {
         let res = "";
         for (let i = 0; i < arr.length; i++) {