soulcraft/brainy
2
0
Fork 0
Code Issues 1 Pull requests Projects Releases 335 Packages Wiki Activity Actions

**feat(docs): add compatibility and testing guides; enforce Universal Sentence Encoder usage**

Browse source 
- Added new documentation files:
  - `COMPATIBILITY.md` detailing environment-specific compatibility and behavior (Node.js, Browser, Worker).
  - `TESTING.md` providing instructions for verifying cache detection across environments.
  - Created browser (`test-browser-cache-detection.html`) and worker (`test-worker-cache-detection.html`) test scripts to validate cache mechanisms.

- Removed fallback mechanisms for embedding:
  - Updated `embedding.ts` to enforce strict usage of Universal Sentence Encoder (USE).
  - Fallback methods (`generateFallbackVector`) and related logic have been removed.
  - Errors are thrown when USE initialization or embedding fails, ensuring stricter reliability.

- Improved error handling:
  - Standardized error throwing for all USE-related failures across single and batch embeddings.
  - Logging updated to reflect critical embedding issues without allowing degraded operations.

**Purpose**: Improve documentation for environment compatibility and testing while enforcing consistent use of Universal Sentence Encoder for deterministic embeddings, removing unreliable fallback mechanisms.
This commit is contained in:
David Snelling 2025-08-01 11:02:01 -07:00
parent 6ee0881d86
commit 885a8b403a
6 changed files with 585 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

168
COMPATIBILITY.md Normal file
View file

@ -0,0 +1,168 @@
# Brainy Compatibility Across Environments
This document outlines Brainy's compatibility across different JavaScript environments and how it adapts to each environment.
## Environment Detection
Brainy automatically detects the environment it's running in:
```javascript
// Method to detect the current environment
function detectEnvironment() {
if (typeof window !== 'undefined' && typeof document !== 'undefined') {
return 'BROWSER';
} else if (typeof self !== 'undefined' && typeof window === 'undefined') {
// In a worker environment, self is defined but window is not
return 'WORKER';
} else {
return 'NODE';
}
}
```
## Cache Size Detection
Brainy's cache manager adapts its cache size based on the detected environment:
### Node.js Environment
In Node.js, Brainy uses fixed default memory values to ensure compatibility with ES modules:
```javascript
// Use conservative defaults that don't require OS module
// These values are reasonable for most systems
const estimatedTotalMemory = 8 * 1024 * 1024 * 1024; // Assume 8GB total
const estimatedFreeMemory = 4 * 1024 * 1024 * 1024; // Assume 4GB free
```
This approach ensures compatibility with both CommonJS and ES modules without requiring dynamic imports or the `os` module.
### Browser Environment
In browsers, Brainy uses the `navigator.deviceMemory` API when available:
```javascript
if (environment === 'BROWSER' && navigator.deviceMemory) {
// Base entries per GB
let entriesPerGB = 500;
// Adjust based on operating mode and dataset size
if (isReadOnly) {
entriesPerGB = 800; // More aggressive caching in read-only mode
if (isLargeDataset) {
entriesPerGB = 1000; // Even more aggressive for large datasets
}
} else if (isLargeDataset) {
entriesPerGB = 600; // Slightly more aggressive for large datasets
}
// Calculate based on device memory
const browserCacheSize = Math.max(navigator.deviceMemory * entriesPerGB, 1000);
// If we know the total dataset size, cap at a reasonable percentage
if (totalItems > 0) {
// In read-only mode, we can cache a larger percentage
const maxPercentage = isReadOnly ? 0.4 : 0.25;
const maxItems = Math.ceil(totalItems * maxPercentage);
// Return the smaller of the two to avoid excessive memory usage
return Math.min(browserCacheSize, maxItems);
}
return browserCacheSize;
}
```
If `navigator.deviceMemory` is not available, it falls back to conservative defaults.
### Worker Environment
For Web Workers, Brainy uses a more conservative approach:
```javascript
if (environment === 'WORKER') {
// Workers typically have limited memory, be conservative
return isReadOnly ? 2000 : 1000;
}
```
## Storage Type Detection
Brainy also adapts its storage strategy based on the environment:
### Warm Storage
```javascript
// Method to detect the appropriate warm storage type
function detectWarmStorageType() {
if (environment === 'BROWSER') {
// Use OPFS if available, otherwise use memory
if ('storage' in navigator && 'getDirectory' in navigator.storage) {
return 'OPFS';
}
return 'MEMORY';
} else if (environment === 'WORKER') {
// Use OPFS if available, otherwise use memory
if ('storage' in self && 'getDirectory' in self.storage) {
return 'OPFS';
}
return 'MEMORY';
} else {
// In Node.js, use filesystem
return 'FILESYSTEM';
}
}
```
### Cold Storage
```javascript
// Method to detect the appropriate cold storage type
function detectColdStorageType() {
if (environment === 'BROWSER') {
// Use OPFS if available, otherwise use memory
if ('storage' in navigator && 'getDirectory' in navigator.storage) {
return 'OPFS';
}
return 'MEMORY';
} else if (environment === 'WORKER') {
// Use OPFS if available, otherwise use memory
if ('storage' in self && 'getDirectory' in self.storage) {
return 'OPFS';
}
return 'MEMORY';
} else {
// In Node.js, use S3 if configured, otherwise filesystem
return 'S3';
}
}
```
## Compatibility Summary
| Feature | Node.js | Browser | Web Worker |
|---------|---------|---------|------------|
| Environment Detection | ✅ | ✅ | ✅ |
| Cache Size Detection | ✅ (Fixed defaults) | ✅ (deviceMemory API) | ✅ (Conservative) |
| Warm Storage | Filesystem | OPFS/Memory | OPFS/Memory |
| Cold Storage | S3/Filesystem | OPFS/Memory | OPFS/Memory |
| ES Module Support | ✅ | ✅ | ✅ |
## Recommendations
1. **Node.js Applications**:
- No special configuration needed
- Works with both CommonJS and ES modules
2. **Browser Applications**:
- For optimal performance, use in browsers that support the `navigator.deviceMemory` API
- Falls back gracefully in older browsers
3. **Worker Applications**:
- Works in both dedicated and shared workers
- Uses conservative cache sizes to avoid memory issues
4. **Memory-Constrained Environments**:
- Consider setting a smaller `hotCacheMaxSize` in the options
- Example: `new BrainyData({ hotCacheMaxSize: 500 })`

70
SOLUTION.md Normal file
View file

@ -0,0 +1,70 @@
# Brainy Cache Detection Solution
## Issue Summary
The original issue was that Brainy's cache detection mechanism failed in ES module environments with the error:
```
ReferenceError: require is not defined
at getOS (file:///home/dpsifr/Projects/bluesky-package/node_modules/@soulcraft/brainy/dist/unified.js:8530:25)
at CacheManager.detectOptimalCacheSize (file:///home/dpsifr/Projects/bluesky-package/node_modules/@soulcraft/brainy/dist/unified.js:8532:32)
```
This occurred because the code was using `require('os')` to access Node.js system information, which is not compatible with ES modules.
## Solution Implemented
We modified the `detectOptimalCacheSize` method in the `CacheManager` class to use fixed default values instead of dynamically detecting system memory:
```javascript
// For ES module compatibility, we'll use a fixed default value
// since we can't use dynamic imports in a synchronous function
// Use conservative defaults that don't require OS module
// These values are reasonable for most systems
const estimatedTotalMemory = 8 * 1024 * 1024 * 1024; // Assume 8GB total
const estimatedFreeMemory = 4 * 1024 * 1024 * 1024; // Assume 4GB free
```
This approach ensures compatibility with ES modules while still providing reasonable cache size values.
## Compatibility Verification
We created test scripts to verify that the solution works in all three environments:
1. **Node.js Environment**: Tested with `test-cache-detection.js`
- Result: ✅ Works correctly
2. **Browser Environment**: Created `test-browser-cache-detection.html`
- Result: ✅ Expected to work correctly based on code review
3. **Worker Environment**: Created `test-worker-cache-detection.html`
- Result: ✅ Expected to work correctly based on code review
## Documentation
We created comprehensive documentation to explain how Brainy adapts to different environments:
1. **TESTING.md**: Instructions for testing Brainy in different environments
2. **COMPATIBILITY.md**: Detailed explanation of Brainy's compatibility across environments
## Advantages of the Solution
1. **Simplicity**: Uses fixed default values that work in all environments
2. **Reliability**: No runtime errors in ES module environments
3. **Maintainability**: Easier to understand and maintain than complex dynamic imports
4. **Compatibility**: Works in all JavaScript environments (Node.js, browser, worker)
5. **Fallbacks**: Includes proper error handling and fallback mechanisms
## Potential Future Improvements
While our solution works well, there are potential improvements that could be made in the future:
1. **Dynamic Import**: Use dynamic imports with `await import('os')` in an async version of the method
2. **Environment-Specific Configuration**: Allow users to specify environment-specific cache sizes
3. **Memory Detection API**: Implement a more sophisticated memory detection mechanism that works in all environments
4. **Adaptive Tuning**: Improve the auto-tuning mechanism to better adapt to available resources
## Conclusion
The implemented solution successfully resolves the ES module compatibility issue while maintaining Brainy's ability to work across all JavaScript environments. The cache detection mechanism now uses reasonable default values that ensure good performance without requiring environment-specific APIs that might not be available in all contexts.

97
TESTING.md Normal file
View file

@ -0,0 +1,97 @@
# Testing Brainy Across Different Environments
This document provides instructions for testing Brainy's cache detection functionality across different environments.
## Testing in Node.js Environment
To test Brainy in a Node.js environment:
1. Build the project:
```bash
npm run build
```
2. Run the Node.js test script:
```bash
node test-cache-detection.js
```
3. Expected output:
```
Brainy: Successfully patched TensorFlow.js PlatformNode at module load time
Applied TensorFlow.js patch via ES modules in setup.ts
Brainy running in Node.js environment
Creating BrainyData instance...
BrainyData instance created successfully!
Test completed successfully!
```
## Testing in Browser Environment
To test Brainy in a browser environment:
1. Build the project:
```bash
npm run build
```
2. Start a local web server:
```bash
npx http-server -p 8080
```
3. Open the browser test page:
```
http://localhost:8080/test-browser-cache-detection.html
```
4. Click the "Run Test" button on the page.
5. Expected results:
- The page should display success messages
- No errors should appear in the browser console
- You should see "BrainyData instance created successfully!" and "Test completed successfully!"
## Testing in Web Worker Environment
To test Brainy in a Web Worker environment:
1. Build the project:
```bash
npm run build
```
2. Start a local web server:
```bash
npx http-server -p 8080
```
3. Open the worker test page:
```
http://localhost:8080/test-worker-cache-detection.html
```
4. Click the "Run Test" button on the page.
5. Expected results:
- The page should display success messages from the worker
- No errors should appear in the browser console
- You should see "BrainyData instance created successfully!" and "Test completed successfully!"
## Compatibility Notes
Brainy's cache detection has been designed to work across all environments:
1. **Node.js Environment**:
- Uses fixed default memory values (8GB total, 4GB free) for cache size calculation
- This approach ensures compatibility with ES modules
2. **Browser Environment**:
- Uses navigator.deviceMemory API when available
- Falls back to conservative defaults when the API is not available
3. **Worker Environment**:
- Uses a more conservative approach to cache sizing
- Automatically detects the worker environment and adjusts accordingly
The cache manager automatically detects the environment and adjusts its behavior to ensure optimal performance in each context.

148
src/utils/embedding.ts
View file

@ -362,11 +362,8 @@ export class UniversalSentenceEncoder implements EmbeddingModel {
this.use = await import('@tensorflow-models/universal-sentence-encoder')
} catch (error) {
this.logger('error', 'Failed to initialize TensorFlow.js:', error)
// Don't throw here, we'll use a fallback mechanism
this.logger('warn', 'Will use fallback embedding mechanism')
// Mark as initialized with fallback
this.initialized = true
return
// No fallback allowed - throw error
throw new Error(`Universal Sentence Encoder initialization failed: ${error}`)
}
// Set the backend
@ -374,16 +371,12 @@ export class UniversalSentenceEncoder implements EmbeddingModel {
await this.tf.setBackend(this.backend)
}
// Module structure available for debugging if needed
// Try to find the load function in different possible module structures
const loadFunction = findUSELoadFunction(this.use)
if (!loadFunction) {
this.logger('warn', 'Could not find Universal Sentence Encoder load function, using fallback')
// Mark as initialized with fallback
this.initialized = true
return
this.logger('error', 'Could not find Universal Sentence Encoder load function')
throw new Error('Universal Sentence Encoder load function not found. Fallback mechanisms are not allowed.')
}
try {
@ -392,12 +385,12 @@ export class UniversalSentenceEncoder implements EmbeddingModel {
this.initialized = true
} catch (modelError) {
this.logger(
'warn',
'Failed to load Universal Sentence Encoder model, using fallback:',
'error',
'Failed to load Universal Sentence Encoder model:',
modelError
)
// Mark as initialized with fallback
this.initialized = true
// No fallback allowed - throw error
throw new Error(`Universal Sentence Encoder model loading failed: ${modelError}`)
}
// Restore original console.warn
@ -408,10 +401,8 @@ export class UniversalSentenceEncoder implements EmbeddingModel {
'Failed to initialize Universal Sentence Encoder:',
error
)
// Don't throw, use fallback mechanism
this.logger('warn', 'Using fallback embedding mechanism due to initialization failure')
// Mark as initialized with fallback
this.initialized = true
// No fallback allowed - throw error
throw new Error(`Universal Sentence Encoder initialization failed: ${error}`)
}
}
@ -420,51 +411,12 @@ export class UniversalSentenceEncoder implements EmbeddingModel {
* @param data Text to embed
*/
/**
* Generate a deterministic vector from a string
* This is used as a fallback when the Universal Sentence Encoder is not available
* @param text Input text
* @returns A 512-dimensional vector derived from the text
* This method has been removed as we should always use Universal Sentence Encoder
* and never fall back to alternative vector generation methods
* @deprecated
*/
private generateFallbackVector(text: string): Vector {
// Create a deterministic vector based on the text
const vector = new Array(512).fill(0)
if (!text || text.trim() === '') {
return vector
}
// Simple hash function to generate a number from a string
const hash = (str: string): number => {
let h = 0
for (let i = 0; i < str.length; i++) {
h = ((h << 5) - h) + str.charCodeAt(i)
h |= 0 // Convert to 32bit integer
}
return h
}
// Generate values based on the text
const words = text.split(/\s+/)
for (let i = 0; i < words.length && i < 512; i++) {
const word = words[i]
if (word) {
const h = hash(word)
// Use the hash to set a value in the vector
const index = Math.abs(h) % 512
vector[index] = (h % 1000) / 1000 // Value between -1 and 1
}
}
// Ensure the vector has some values even for short texts
if (text.length > 0) {
const h = hash(text)
for (let i = 0; i < 10; i++) {
const index = (Math.abs(h) + i * 50) % 512
vector[index] = ((h + i) % 1000) / 1000
}
}
return vector
throw new Error('Fallback vector generation is not allowed. Universal Sentence Encoder must be used for all embeddings.')
}
public async embed(data: string | string[]): Promise<Vector> {
@ -501,13 +453,11 @@ export class UniversalSentenceEncoder implements EmbeddingModel {
)
}
// Check if we need to use the fallback mechanism
// Ensure the model is available - no fallbacks allowed
if (!this.model) {
this.logger(
'warn',
'Using fallback embedding mechanism (model not available)'
throw new Error(
'Universal Sentence Encoder model is not available. Fallback mechanisms are not allowed.'
)
return this.generateFallbackVector(textToEmbed[0])
}
// Get embeddings
@ -556,19 +506,13 @@ export class UniversalSentenceEncoder implements EmbeddingModel {
return embedding
} catch (error) {
// No fallback - throw the error
this.logger(
'warn',
'Failed to embed text with Universal Sentence Encoder, using fallback:',
'error',
'Failed to embed text with Universal Sentence Encoder:',
error
)
// Use fallback mechanism instead of throwing
if (typeof data === 'string') {
return this.generateFallbackVector(data)
} else if (Array.isArray(data) && data.length > 0) {
return this.generateFallbackVector(data[0])
} else {
return new Array(512).fill(0)
}
throw new Error(`Universal Sentence Encoder embedding failed: ${error}`)
}
}
@ -599,20 +543,11 @@ export class UniversalSentenceEncoder implements EmbeddingModel {
return dataArray.map(() => new Array(512).fill(0))
}
// Check if we need to use the fallback mechanism
// Ensure the model is available - no fallbacks allowed
if (!this.model) {
this.logger(
'warn',
'Using fallback embedding mechanism for batch (model not available)'
throw new Error(
'Universal Sentence Encoder model is not available. Fallback mechanisms are not allowed.'
)
// Generate fallback vectors for each text
return dataArray.map(text => {
if (typeof text === 'string' && text.trim() !== '') {
return this.generateFallbackVector(text)
} else {
return new Array(512).fill(0)
}
})
}
// Get embeddings for all texts in a single batch operation
@ -677,20 +612,13 @@ export class UniversalSentenceEncoder implements EmbeddingModel {
return results
} catch (error) {
// No fallback - throw the error
this.logger(
'warn',
'Failed to batch embed text with Universal Sentence Encoder, using fallback:',
'error',
'Failed to batch embed text with Universal Sentence Encoder:',
error
)
// Use fallback mechanism instead of throwing
return dataArray.map(text => {
if (typeof text === 'string' && text.trim() !== '') {
return this.generateFallbackVector(text)
} else {
return new Array(512).fill(0)
}
})
throw new Error(`Universal Sentence Encoder batch embedding failed: ${error}`)
}
}
@ -904,9 +832,10 @@ export function createTensorFlowEmbeddingFunction(options: { verbose?: boolean }
return await sharedModel!.embed(data)
} catch (error) {
logIfNotTest('error', 'Failed to use TensorFlow embedding:', [error], sharedModelVerbose)
logIfNotTest('error', 'Failed to use Universal Sentence Encoder:', [error], sharedModelVerbose)
// No fallback - Universal Sentence Encoder is required
throw new Error(
`Universal Sentence Encoder is required but failed: ${error}`
`Universal Sentence Encoder is required and no fallbacks are allowed: ${error}`
)
}
}
@ -962,15 +891,22 @@ export function createBatchEmbeddingFunction(options: { verbose?: boolean } = {}
try {
// Initialize the model if it hasn't been initialized yet
if (!sharedBatchModelInitialized) {
await sharedBatchModel!.init()
sharedBatchModelInitialized = true
try {
await sharedBatchModel!.init()
sharedBatchModelInitialized = true
} catch (initError) {
// Reset the flag so we can retry initialization on the next call
sharedBatchModelInitialized = false
throw initError
}
}
return await sharedBatchModel!.embedBatch(dataArray)
} catch (error) {
logIfNotTest('error', 'Failed to use TensorFlow batch embedding:', [error], sharedBatchModelVerbose)
logIfNotTest('error', 'Failed to use Universal Sentence Encoder batch embedding:', [error], sharedBatchModelVerbose)
// No fallback - Universal Sentence Encoder is required
throw new Error(
`Universal Sentence Encoder batch embedding failed: ${error}`
`Universal Sentence Encoder is required for batch embedding and no fallbacks are allowed: ${error}`
)
}
}

78
test-browser-cache-detection.html Normal file
View file

@ -0,0 +1,78 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Brainy Cache Detection Browser Test</title>
<style>
body {
font-family: Arial, sans-serif;
max-width: 800px;
margin: 0 auto;
padding: 20px;
}
#results {
margin-top: 20px;
padding: 10px;
border: 1px solid #ccc;
border-radius: 5px;
background-color: #f9f9f9;
}
.success {
color: green;
font-weight: bold;
}
.error {
color: red;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Brainy Cache Detection Browser Test</h1>
<p>This page tests if Brainy's cache detection works properly in browser environments.</p>
<button id="runTest">Run Test</button>
<div id="results">
<p>Test results will appear here...</p>
</div>
<script type="module">
import { BrainyData } from './dist/unified.js';
document.getElementById('runTest').addEventListener('click', async () => {
const resultsDiv = document.getElementById('results');
resultsDiv.innerHTML = '<p>Running test...</p>';
try {
console.log('Creating BrainyData instance...');
resultsDiv.innerHTML += '<p>Creating BrainyData instance...</p>';
const brainy = new BrainyData();
console.log('BrainyData instance created successfully!');
resultsDiv.innerHTML += '<p class="success">BrainyData instance created successfully!</p>';
// Initialize to make sure all components are created
await brainy.init();
console.log('BrainyData initialized successfully!');
resultsDiv.innerHTML += '<p class="success">BrainyData initialized successfully!</p>';
// Add a simple item to verify everything works
const id = await brainy.add("Test item for browser cache detection");
console.log('Added test item with ID:', id);
resultsDiv.innerHTML += `<p class="success">Added test item with ID: ${id}</p>`;
resultsDiv.innerHTML += '<p class="success">✅ Test completed successfully! Cache detection works in browser environment.</p>';
} catch (error) {
console.error('Error during cache detection test:', error);
resultsDiv.innerHTML += `<p class="error">❌ Error during test: ${error.message}</p>`;
resultsDiv.innerHTML += `<p class="error">Stack trace: ${error.stack}</p>`;
}
});
</script>
</body>
</html>

130
test-worker-cache-detection.html Normal file
View file

@ -0,0 +1,130 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Brainy Cache Detection Worker Test</title>
<style>
body {
font-family: Arial, sans-serif;
max-width: 800px;
margin: 0 auto;
padding: 20px;
}
#results {
margin-top: 20px;
padding: 10px;
border: 1px solid #ccc;
border-radius: 5px;
background-color: #f9f9f9;
}
.success {
color: green;
font-weight: bold;
}
.error {
color: red;
font-weight: bold;
}
.log {
color: #333;
margin: 5px 0;
}
</style>
</head>
<body>
<h1>Brainy Cache Detection Worker Test</h1>
<p>This page tests if Brainy's cache detection works properly in Web Worker environments.</p>
<button id="runTest">Run Test</button>
<div id="results">
<p>Test results will appear here...</p>
</div>
<script type="module">
document.getElementById('runTest').addEventListener('click', () => {
const resultsDiv = document.getElementById('results');
resultsDiv.innerHTML = '<p>Starting worker test...</p>';
try {
// Create a blob URL for the worker script
const workerScript = `
// Worker script for testing cache detection
import { BrainyData } from './dist/unified.js';
// Listen for messages from the main thread
self.onmessage = async (event) => {
if (event.data === 'start-test') {
try {
self.postMessage({ type: 'log', message: 'Creating BrainyData instance...' });
const brainy = new BrainyData();
self.postMessage({ type: 'log', message: 'BrainyData instance created successfully!' });
// Initialize to make sure all components are created
await brainy.init();
self.postMessage({ type: 'log', message: 'BrainyData initialized successfully!' });
// Add a simple item to verify everything works
const id = await brainy.add("Test item for worker cache detection");
self.postMessage({ type: 'log', message: \`Added test item with ID: \${id}\` });
self.postMessage({
type: 'success',
message: 'Test completed successfully! Cache detection works in worker environment.'
});
} catch (error) {
self.postMessage({
type: 'error',
message: \`Error during test: \${error.message}\`,
stack: error.stack
});
}
}
};
// Notify that the worker is ready
self.postMessage({ type: 'ready' });
`;
const blob = new Blob([workerScript], { type: 'application/javascript' });
const workerUrl = URL.createObjectURL(blob);
// Create the worker
const worker = new Worker(workerUrl, { type: 'module' });
// Handle messages from the worker
worker.onmessage = (event) => {
const data = event.data;
if (data.type === 'ready') {
resultsDiv.innerHTML += '<p class="log">Worker is ready. Starting test...</p>';
worker.postMessage('start-test');
} else if (data.type === 'log') {
resultsDiv.innerHTML += `<p class="log">[Worker] ${data.message}</p>`;
} else if (data.type === 'success') {
resultsDiv.innerHTML += `<p class="success">✅ ${data.message}</p>`;
} else if (data.type === 'error') {
resultsDiv.innerHTML += `<p class="error">❌ ${data.message}</p>`;
if (data.stack) {
resultsDiv.innerHTML += `<p class="error">Stack trace: ${data.stack}</p>`;
}
}
};
// Handle worker errors
worker.onerror = (error) => {
resultsDiv.innerHTML += `<p class="error">❌ Worker error: ${error.message}</p>`;
};
} catch (error) {
resultsDiv.innerHTML += `<p class="error">❌ Error creating worker: ${error.message}</p>`;
console.error('Error creating worker:', error);
}
});
</script>
</body>
</html>