fiptcha 0.1.0

package/src/captcha-model-manager.js

@@ -0,0 +1,375 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { MODEL_MANIFESTS } = require('./captcha-model-manifest');
+const { downloadModelArtifacts, verifyArtifactDirectory, checksumFile } = require('./captcha-model-downloader');
+const { getMemorySnapshot, getResourceSnapshot } = require('./captcha-resources');
+const { detectWithCompanion } = require('./captcha-companion-client');
+
+const MODEL_ROOT = path.resolve(process.env.CAPTCHA_MODEL_CACHE_DIR || path.join(process.cwd(), 'data', 'captcha-model'));
+const RECONCILE_INTERVAL_MS = 60_000;
+const PROBE_PNG = Buffer.from(
+    'iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAGUlEQVR4nO3BAQ0AAADCoPdPbQ43oAAAAAAAAAB4Gx4gAAE7Bq0AAAAASUVORK5CYII=',
+    'base64'
+);
+
+const parseFlag = (value) => ['1', 'true', 'yes', 'on'].includes(String(value || '').trim().toLowerCase());
+
+function normalizedResources(input = getMemorySnapshot()) {
+    if (input.memory) return input;
+    return { memory: input, accelerators: [], companion: null, onnxBackends: ['cpu'] };
+}
+
+function acceleratorCapacity(resources) {
+    return (resources.accelerators || []).reduce((best, accelerator) => {
+        const totalMb = Number(accelerator.totalMb) || 0;
+        const availableMb = Number(accelerator.availableMb) || 0;
+        if (totalMb > best.totalMb || (totalMb === best.totalMb && availableMb > best.availableMb)) {
+            return { ...accelerator, totalMb, availableMb };
+        }
+        return best;
+    }, { type: null, totalMb: 0, availableMb: 0 });
+}
+
+function qualifiesMemory(memory, definition) {
+    return Number(memory?.totalMb) >= definition.minimumTotalMb
+        && Number(memory?.availableMb) >= definition.minimumAvailableMb;
+}
+
+function qualifyingAccelerator(resources, definition) {
+    return (resources.accelerators || []).find((accelerator) =>
+        Number(accelerator.totalMb) >= definition.minimumTotalMb
+        && Number(accelerator.availableMb) >= definition.minimumAvailableMb);
+}
+
+function selectModelTier(input = getMemorySnapshot(), env = process.env) {
+    if (parseFlag(env.SKIP_LOCAL_CAPTCHA_MODEL)) return null;
+    const resources = normalizedResources(input);
+    const requested = String(env.CAPTCHA_MODEL_TIER || 'auto').trim().toLowerCase();
+    if (!['auto', 'owlvit', 'florence2'].includes(requested)) {
+        throw new Error(`Invalid CAPTCHA_MODEL_TIER "${requested}"; expected auto, owlvit, or florence2`);
+    }
+    const forceCpu = String(env.CAPTCHA_MODEL_DEVICE || 'auto').trim().toLowerCase() === 'cpu';
+    const owlQualified = qualifiesMemory(resources.memory, MODEL_MANIFESTS.owlvit)
+        || (!forceCpu && Boolean(qualifyingAccelerator(resources, MODEL_MANIFESTS.owlvit)));
+    if (!owlQualified) return null;
+    const florenceQualified = qualifiesMemory(resources.memory, MODEL_MANIFESTS.florence2)
+        || (!forceCpu && Boolean(qualifyingAccelerator(resources, MODEL_MANIFESTS.florence2)));
+    if (requested === 'florence2' && !florenceQualified) {
+        throw new Error('CAPTCHA_MODEL_TIER=florence2 requires at least 8 GiB effective memory and 2 GiB available');
+    }
+    if (requested === 'owlvit') return 'owlvit';
+    return florenceQualified ? 'florence2' : 'owlvit';
+}
+
+function selectModelBackend(tier, input) {
+    const resources = normalizedResources(input);
+    const forceCpu = String(process.env.CAPTCHA_MODEL_DEVICE || 'auto').trim().toLowerCase() === 'cpu';
+    const companion = (resources.accelerators || []).find((item) => item.type === 'companion');
+    const definition = MODEL_MANIFESTS[tier];
+    if (!forceCpu && companion && qualifiesMemory(companion, definition)) {
+        return { type: 'companion', device: companion.backend || 'coreml' };
+    }
+    const device = selectModelDevice(process.env, resources);
+    if (qualifiesMemory(resources.memory, definition)) return { type: 'local', device };
+    const accelerator = (resources.accelerators || []).find((item) => item.type === device && qualifiesMemory(item, definition));
+    if (device !== 'cpu' && accelerator && qualifiesMemory(resources.memory, MODEL_MANIFESTS.owlvit)) {
+        return { type: 'local', device };
+    }
+    return null;
+}
+
+function selectModelDevice(env = process.env, resources = { onnxBackends: ['cpu'], accelerators: [] }) {
+    const requested = String(env.CAPTCHA_MODEL_DEVICE || 'auto').trim().toLowerCase();
+    if (!['auto', 'cpu'].includes(requested)) {
+        throw new Error(`Invalid CAPTCHA_MODEL_DEVICE "${requested}"; expected auto or cpu`);
+    }
+    if (requested === 'cpu') return 'cpu';
+    if (parseFlag(env.CAPTCHA_COMPANION_MODE) && process.platform === 'darwin' && resources.onnxBackends?.includes('coreml')) return 'coreml';
+    if (resources.accelerators?.some((item) => item.type === 'cuda') && resources.onnxBackends?.includes('cuda')) return 'cuda';
+    if (resources.accelerators?.some((item) => item.type === 'webgpu') && resources.onnxBackends?.includes('webgpu')) return 'webgpu';
+    if (process.platform === 'darwin' && resources.onnxBackends?.includes('coreml')) return 'coreml';
+    return 'cpu';
+}
+
+function isCapacityFailure(error) {
+    return /out of memory|oom|allocation|capacity|execution provider|device.*lost|cuda|coreml|webgpu/i.test(error?.message || '');
+}
+
+function modelThreshold(tier, env = process.env) {
+    const variable = tier === 'florence2' ? 'CAPTCHA_FLORENCE2_THRESHOLD' : 'CAPTCHA_OWLVIT_THRESHOLD';
+    const configured = Number(env[variable]);
+    return Number.isFinite(configured) && configured >= 0 && configured <= 1
+        ? configured
+        : MODEL_MANIFESTS[tier].threshold;
+}
+
+class CaptchaModelManager {
+    constructor(options = {}) {
+        this.activeTier = null;
+        this.activeRuntime = null;
+        this.activeBackend = null;
+        this.reconcilePromise = null;
+        this.inferenceQueue = Promise.resolve();
+        this.timer = null;
+        this.lastError = null;
+        this.resourceProvider = options.resourceProvider || (() => getResourceSnapshot({ skipCompanion: parseFlag(process.env.CAPTCHA_COMPANION_MODE) }));
+        this.downloader = options.downloader || downloadModelArtifacts;
+        this.verifier = options.verifier || verifyArtifactDirectory;
+        this.runtimeLoader = options.runtimeLoader || ((tier, modelDir, device) => this._loadLocalRuntime(tier, modelDir, device));
+        this.modelRoot = options.modelRoot ? path.resolve(options.modelRoot) : MODEL_ROOT;
+    }
+
+    isSkipped() {
+        return parseFlag(process.env.SKIP_LOCAL_CAPTCHA_MODEL);
+    }
+
+    cachePath(...segments) {
+        const target = path.resolve(this.modelRoot, ...segments);
+        if (target !== this.modelRoot && !target.startsWith(`${this.modelRoot}${path.sep}`)) throw new Error('Unsafe CAPTCHA cache path');
+        return target;
+    }
+
+    async start() {
+        if (this.isSkipped() || this.timer) return;
+        await fs.promises.mkdir(this.modelRoot, { recursive: true });
+        const entries = await fs.promises.readdir(this.modelRoot, { withFileTypes: true });
+        for (const entry of entries) if (entry.name.startsWith('.staging-')) {
+            await fs.promises.rm(this.cachePath(entry.name), { recursive: true, force: true });
+        }
+        this.timer = setInterval(() => this.reconcile().catch((error) => {
+            this.lastError = error;
+            console.warn('[CAPTCHA_MODEL] Reconciliation failed:', error.message);
+        }), RECONCILE_INTERVAL_MS);
+        this.timer.unref?.();
+        await this.reconcile();
+    }
+
+    async stop() {
+        if (this.timer) clearInterval(this.timer);
+        this.timer = null;
+        await this.activeRuntime?.dispose?.().catch?.(() => undefined);
+        this.activeRuntime = null;
+        this.activeTier = null;
+        this.activeBackend = null;
+    }
+
+    async reconcile() {
+        if (this.reconcilePromise) return this.reconcilePromise;
+        this.reconcilePromise = this._reconcile().finally(() => { this.reconcilePromise = null; });
+        return this.reconcilePromise;
+    }
+
+    async _reconcile() {
+        if (this.isSkipped()) {
+            await this.stop();
+            return null;
+        }
+        const resources = await this.resourceProvider();
+        const targetTier = selectModelTier(resources);
+        if (!targetTier) {
+            await this.activeRuntime?.dispose?.().catch?.(() => undefined);
+            this.activeRuntime = null;
+            this.activeTier = null;
+            this.activeBackend = null;
+            this.lastError = new Error('No local or companion CAPTCHA model has sufficient effective memory');
+            return null;
+        }
+        const targetBackend = selectModelBackend(targetTier, resources);
+        if (!targetBackend) {
+            await this.activeRuntime?.dispose?.().catch?.(() => undefined);
+            this.activeRuntime = null;
+            this.activeTier = null;
+            this.activeBackend = null;
+            this.lastError = new Error('No healthy CAPTCHA inference backend is available');
+            return null;
+        }
+        if (this.activeTier === targetTier
+            && this.activeBackend?.type === targetBackend.type
+            && this.activeBackend?.device === targetBackend.device
+            && this.activeRuntime) return this.activeRuntime;
+
+        let runtime;
+        if (targetBackend.type === 'companion') {
+            runtime = this._companionRuntime(targetTier, targetBackend.device);
+            await runtime.probe();
+        } else {
+            const stagingDir = this.cachePath(`.staging-${targetTier}`);
+            const targetDir = this.cachePath(targetTier);
+            let hasCachedModel = await this.verifier(targetTier, targetDir).catch(() => false);
+            if (!hasCachedModel) {
+                await fs.promises.rm(targetDir, { recursive: true, force: true });
+                await fs.promises.rm(stagingDir, { recursive: true, force: true });
+                await fs.promises.mkdir(stagingDir, { recursive: true });
+                try {
+                    await this.downloader(targetTier, stagingDir);
+                } catch (error) {
+                    const outOfDisk = error?.code === 'ENOSPC' || /no space left|ENOSPC/i.test(error?.message || '');
+                    if (!outOfDisk || !this.activeTier || this.activeBackend?.type !== 'local') throw error;
+                    await this.activeRuntime?.dispose?.().catch?.(() => undefined);
+                    this.activeRuntime = null;
+                    const oldTier = this.activeTier;
+                    this.activeTier = null;
+                    this.activeBackend = null;
+                    await fs.promises.rm(this.cachePath(oldTier), { recursive: true, force: true });
+                    await fs.promises.rm(stagingDir, { recursive: true, force: true });
+                    await fs.promises.mkdir(stagingDir, { recursive: true });
+                    await this.downloader(targetTier, stagingDir);
+                }
+                if (!await this.verifier(targetTier, stagingDir)) throw new Error(`Downloaded ${targetTier} model failed verification`);
+                await fs.promises.rename(stagingDir, targetDir);
+            }
+            try {
+                runtime = await this.runtimeLoader(targetTier, targetDir, targetBackend.device);
+                await runtime.probe();
+            } catch (error) {
+                await runtime?.dispose?.().catch?.(() => undefined);
+                if (this.activeTier !== targetTier) await fs.promises.rm(targetDir, { recursive: true, force: true });
+                throw error;
+            }
+        }
+
+        const previous = { runtime: this.activeRuntime, tier: this.activeTier };
+        this.activeRuntime = runtime;
+        this.activeTier = targetTier;
+        this.activeBackend = targetBackend;
+        this.lastError = null;
+        await fs.promises.mkdir(this.modelRoot, { recursive: true });
+        const activeFile = this.cachePath('active.json');
+        const activeStaging = this.cachePath('.active.json.tmp');
+        await fs.promises.writeFile(activeStaging, JSON.stringify({
+            tier: targetTier,
+            model: MODEL_MANIFESTS[targetTier].id,
+            revision: MODEL_MANIFESTS[targetTier].revision,
+            backend: targetBackend.type,
+            device: targetBackend.device,
+            activatedAt: new Date().toISOString()
+        }, null, 2), { mode: 0o600 });
+        await fs.promises.rename(activeStaging, activeFile);
+        await previous.runtime?.dispose?.().catch?.(() => undefined);
+        for (const tier of Object.keys(MODEL_MANIFESTS)) {
+            if (tier !== targetTier) await fs.promises.rm(this.cachePath(tier), { recursive: true, force: true });
+        }
+        for (const tier of Object.keys(MODEL_MANIFESTS)) {
+            await fs.promises.rm(this.cachePath(`.staging-${tier}`), { recursive: true, force: true });
+        }
+        console.log(`[CAPTCHA_MODEL] Activated ${targetTier} via ${targetBackend.type}/${targetBackend.device}${previous.tier ? ` (replaced ${previous.tier})` : ''}`);
+        return runtime;
+    }
+
+    _companionRuntime(tier, device) {
+        return {
+            tier,
+            device,
+            async detect(imageBuffer, label, threshold) {
+                const result = await detectWithCompanion(imageBuffer, label, tier, threshold);
+                return result.detections;
+            },
+            async probe() {
+                await detectWithCompanion(PROBE_PNG, 'object', tier, 0.99, 20_000);
+            }
+        };
+    }
+
+    async _loadLocalRuntime(tier, modelDir, device) {
+        const definition = MODEL_MANIFESTS[tier];
+        const transformers = await import('@huggingface/transformers');
+        transformers.env.allowRemoteModels = false;
+        transformers.env.allowLocalModels = true;
+        transformers.env.useFSCache = false;
+        const common = { dtype: definition.dtype, device, local_files_only: true };
+        if (definition.kind === 'owlvit') {
+            const detector = await transformers.pipeline('zero-shot-object-detection', modelDir, common);
+            return {
+                tier,
+                device,
+                async detect(imageBuffer, label, threshold = definition.threshold) {
+                    const image = await transformers.RawImage.fromBlob(new Blob([imageBuffer], { type: 'image/png' }));
+                    const detections = await detector(image, [label], { threshold });
+                    return Array.isArray(detections) ? detections : [];
+                },
+                async probe() { await this.detect(PROBE_PNG, 'object', 0.99); },
+                async dispose() { await detector.dispose?.(); }
+            };
+        }
+        const model = await transformers.Florence2ForConditionalGeneration.from_pretrained(modelDir, common);
+        const processor = await transformers.AutoProcessor.from_pretrained(modelDir, { local_files_only: true });
+        const tokenizer = await transformers.AutoTokenizer.from_pretrained(modelDir, { local_files_only: true });
+        return {
+            tier,
+            device,
+            async detect(imageBuffer, label, threshold = definition.threshold) {
+                const image = await transformers.RawImage.fromBlob(new Blob([imageBuffer], { type: 'image/png' }));
+                const task = `<OPEN_VOCABULARY_DETECTION>${label}`;
+                const prompts = processor.construct_prompts(task);
+                const inputs = await processor(image, prompts);
+                const generated = await model.generate({ ...inputs, max_new_tokens: 64, num_beams: 1 });
+                const decoded = tokenizer.batch_decode(generated, { skip_special_tokens: false })[0];
+                const parsed = processor.post_process_generation(decoded, task, image.size);
+                const value = parsed?.[task] || parsed?.['<OPEN_VOCABULARY_DETECTION>'] || parsed || {};
+                const boxes = value.bboxes || value.boxes || [];
+                const labels = value.labels || [];
+                return boxes.map((box, index) => ({ box, label: labels[index] || label, score: threshold }));
+            },
+            async probe() { await this.detect(PROBE_PNG, 'object', 0.99); },
+            async dispose() { await model.dispose?.(); }
+        };
+    }
+
+    async detect(imageBuffer, label, threshold) {
+        if (this.isSkipped()) throw new Error('Local CAPTCHA model disabled by SKIP_LOCAL_CAPTCHA_MODEL');
+        const run = async () => {
+            const runtime = await this.reconcile();
+            if (!runtime) throw this.lastError || new Error('Local CAPTCHA model is unavailable');
+            try {
+                return await runtime.detect(imageBuffer, label, threshold ?? modelThreshold(this.activeTier));
+            } catch (error) {
+                if (isCapacityFailure(error)) {
+                    await runtime.dispose?.().catch?.(() => undefined);
+                    this.activeRuntime = null;
+                    this.activeTier = null;
+                    this.activeBackend = null;
+                    this.lastError = error;
+                    this.reconcile().catch(() => undefined);
+                }
+                throw error;
+            }
+        };
+        const resultPromise = this.inferenceQueue.then(run, run);
+        this.inferenceQueue = resultPromise.catch(() => undefined);
+        return resultPromise;
+    }
+
+    status() {
+        return {
+            healthy: Boolean(this.activeRuntime),
+            activeTier: this.activeTier,
+            backend: this.activeBackend?.type || null,
+            device: this.activeBackend?.device || null,
+            error: this.lastError?.message || null
+        };
+    }
+}
+
+const captchaModelManager = new CaptchaModelManager();
+
+function checksumBuffer(buffer) {
+    return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+module.exports = {
+    MODEL_DEFINITIONS: MODEL_MANIFESTS,
+    MODEL_MANIFESTS,
+    CaptchaModelManager,
+    captchaModelManager,
+    getMemorySnapshot,
+    selectModelTier,
+    selectModelBackend,
+    selectModelDevice,
+    qualifiesMemory,
+    checksumBuffer,
+    checksumFile,
+    parseFlag,
+    modelThreshold,
+    isCapacityFailure
+};

package/src/captcha-model-manifest.js

@@ -0,0 +1,74 @@
+const MODEL_MANIFESTS = Object.freeze({
+    owlvit: Object.freeze({
+        id: 'Xenova/owlvit-base-patch32',
+        revision: 'b75f4e52949639c3bb0b96546ea4149482f6e7ef',
+        dtype: 'q8',
+        kind: 'owlvit',
+        // 2 GB in provider/VM sizing is decimal bytes (~1907 MiB), not 2 GiB.
+        minimumTotalMb: 1907,
+        minimumAvailableMb: 512,
+        threshold: 0.12,
+        files: Object.freeze([
+            { path: 'config.json', size: 583, sha256: 'd64b634b32bcc85f1580d103f731a6949d9cbb9749f19eb75b6e06c86b81eb28' },
+            { path: 'merges.txt', size: 524619, sha256: '9fd691f7c8039210e0fced15865466c65820d09b63988b0174bfe25de299051a' },
+            { path: 'preprocessor_config.json', size: 576, sha256: '7f1386f6b36981b62f76447375ec20470656179fea4e47b6e22e2d896376e8ce' },
+            { path: 'special_tokens_map.json', size: 460, sha256: 'f118ab3a983206e4f32583448de6bd6aae4ee21869135cef1f5848a753cdaab6' },
+            { path: 'tokenizer.json', size: 2224253, sha256: '50b24e94079fb11cb1503f65fef0ed08044186a1cd118c79683991554d9a5b23' },
+            { path: 'tokenizer_config.json', size: 925, sha256: '2c49c1bc8de9f6f5189fb3e6cbadfe656431174a83064be3aac4f6e0f131f7d0' },
+            { path: 'vocab.json', size: 862328, sha256: '5047b556ce86ccaf6aa22b3ffccfc52d391ea4accdab9c2f2407da5b742d4363' },
+            { path: 'onnx/model_quantized.onnx', size: 155431700, sha256: '06af49bd5db977936bcddad2b45d0031072673517579d15b8cb42bf015a94156' }
+        ])
+    }),
+    florence2: Object.freeze({
+        id: 'onnx-community/Florence-2-base-ft',
+        revision: 'e88a44eaf3791a35eae0c5a47b3dbcd36e67eb6f',
+        dtype: Object.freeze({
+            embed_tokens: 'fp16',
+            vision_encoder: 'fp16',
+            encoder_model: 'q4',
+            decoder_model_merged: 'q4'
+        }),
+        kind: 'florence2',
+        minimumTotalMb: 8192,
+        minimumAvailableMb: 2048,
+        threshold: 0.18,
+        files: Object.freeze([
+            { path: 'added_tokens.json', size: 22410, sha256: 'ba67457c577895525996e7a42d7da60a05856506ea4fd25ff9a023a64662f74b' },
+            { path: 'config.json', size: 5432, sha256: 'd90c22ed72eb55291f183fcd9b98ebd3bd3d92bfcffb6c7f6e1606085e793525' },
+            { path: 'generation_config.json', size: 292, sha256: '7b8eb17bbd6cf8a07f619ad83ae03881eff05b6b9237bab89005b40e77783c29' },
+            { path: 'merges.txt', size: 456318, sha256: '1ce1664773c50f3e0cc8842619a93edc4624525b728b188a9e0be33b7726adc5' },
+            { path: 'preprocessor_config.json', size: 2673, sha256: 'c892857e34a7082284983a7717717d39c9bf7e574f1f41d80d4c918c97502efa' },
+            { path: 'special_tokens_map.json', size: 146627, sha256: '72ff172dc769bc1551b1b4211628ce3271643bc60379e4da45d85a9be9332c39' },
+            { path: 'tokenizer.json', size: 2297961, sha256: 'd69dcdb2323e124ac4f800cb9863ddccea0d7bb11e16125e8df3bd60f2f8aeac' },
+            { path: 'tokenizer_config.json', size: 197658, sha256: 'd8e64607233cb53b619fb46664f6cad08176c26e0e8735b2d30d888364f19600' },
+            { path: 'vocab.json', size: 1099884, sha256: '394fdc63c71aabe0a9b97117f5d62fb5fcc4d59b2b3ea929a3929e6a53217b3c' },
+            { path: 'onnx/embed_tokens_fp16.onnx', size: 78780290, sha256: 'da2607930eea5e21e4a2bd5fd069de550f1acc30316a4e8f824551a95232ba39' },
+            { path: 'onnx/vision_encoder_fp16.onnx', size: 183930536, sha256: 'a7abcd77199c5d0089cf985ede4dd8089acd84f30fb3fb1462d5930345c688b3' },
+            { path: 'onnx/encoder_model_q4.onnx', size: 30058778, sha256: '34b17bcf191dacb79bd482b94bad5cf1ba39bc770f6a4c9ae26f28b89c235e4b' },
+            { path: 'onnx/decoder_model_merged_q4.onnx', size: 64393474, sha256: 'be7a2f33e65f8d65538024772fda4d1c5a7752d60a7159aadf53f9f4798b90fa' }
+        ])
+    })
+});
+
+const APPLE_MLX_MANIFEST = Object.freeze({
+    id: 'mlx-community/Florence-2-base-ft-4bit',
+    revision: 'cfed5ed3e86826b6aa2902abf6cf2e406fd94504',
+    kind: 'florence2-mlx',
+    threshold: 0.18,
+    files: Object.freeze([
+        { path: 'added_tokens.json', size: 22410, sha256: 'ba67457c577895525996e7a42d7da60a05856506ea4fd25ff9a023a64662f74b' },
+        { path: 'config.json', size: 6703, sha256: '7f45016c8c9941e33939269e28c28ea2adca3dfe8ae2b8e21f9ceab4953f396f' },
+        { path: 'merges.txt', size: 456318, sha256: '1ce1664773c50f3e0cc8842619a93edc4624525b728b188a9e0be33b7726adc5' },
+        { path: 'model.safetensors', size: 163524711, sha256: '904321eedba8cf7bb1d7258e08d4efb6b8b2f62dc154d530b7ff663f240df533' },
+        { path: 'model.safetensors.index.json', size: 96965, sha256: '3a5d577309a948bacd44141544167fd60d6dc7e8ad8825e0ec728fbce56369a1' },
+        { path: 'preprocessor_config.json', size: 603, sha256: '1396ec5a0a7adfe1c04fb777b09e8ba753be6dbb5868212ab3c3ef39d91fe031' },
+        { path: 'processing_florence2.py', size: 46372, sha256: '4bd7158536cbf1c7891fc8efd94437d79fd09f07f539c7398fab8a885d7d8bca' },
+        { path: 'processor_config.json', size: 130, sha256: '6eb1a2e487fa8b7521691a3382b5afd92a78e8ea34b385f8824fa07563e92245' },
+        { path: 'special_tokens_map.json', size: 439927, sha256: '20f95a5768e5d9d14ab9bebbf844c1750ece27765109ce35be9a629db630aedc' },
+        { path: 'tokenizer.json', size: 3747961, sha256: '9b466914d9e7f9a39936c9bbe2ac28c86cd8b35c83a905699b01f83178f27c51' },
+        { path: 'tokenizer_config.json', size: 232317, sha256: '06e57de7118812e63652f83c779ed1608712418c37cd8f7e4cec4380c6f43810' },
+        { path: 'vocab.json', size: 798293, sha256: 'ed19656ea1707df69134c4af35c8ceda2cc9860bf2c3495026153a133670ab5e' }
+    ])
+});
+
+module.exports = { MODEL_MANIFESTS, APPLE_MLX_MANIFEST };

package/src/captcha-resources.js

@@ -0,0 +1,128 @@
+const os = require('os');
+const fs = require('fs');
+const { execFile, execFileSync } = require('child_process');
+const { promisify } = require('util');
+const { probeCompanion } = require('./captcha-companion-client');
+
+const execFileAsync = promisify(execFile);
+
+function readNumericFile(filePath, readFile = fs.readFileSync) {
+    try {
+        const raw = readFile(filePath, 'utf8').trim();
+        if (!raw || raw === 'max') return null;
+        const value = Number(raw);
+        return Number.isFinite(value) && value > 0 ? value : null;
+    } catch {
+        return null;
+    }
+}
+
+function parseMacAvailableMemory(vmStatOutput) {
+    const text = String(vmStatOutput || '');
+    const pageSize = Number(text.match(/page size of\s+(\d+)\s+bytes/i)?.[1]);
+    if (!Number.isFinite(pageSize) || pageSize <= 0) return null;
+    const pages = { free: 0, inactive: 0, speculative: 0 };
+    for (const match of text.matchAll(/Pages\s+(free|inactive|speculative):\s*(\d+)\.?/gi)) {
+        pages[match[1].toLowerCase()] = Number(match[2]);
+    }
+    const availablePages = pages.free + pages.inactive + pages.speculative;
+    return availablePages > 0 ? availablePages * pageSize : null;
+}
+
+function readMacAvailableMemory(runVmStat = () => execFileSync('vm_stat', { encoding: 'utf8', timeout: 1500, maxBuffer: 64 * 1024 })) {
+    try {
+        return parseMacAvailableMemory(runVmStat());
+    } catch {
+        return null;
+    }
+}
+
+function getMemorySnapshot(overrides = {}) {
+    const readFile = overrides.readFile || fs.readFileSync;
+    const platform = overrides.platform || process.platform;
+    const hostTotalBytes = overrides.hostTotalBytes ?? os.totalmem();
+    const macAvailableBytes = overrides.macAvailableBytes
+        ?? (platform === 'darwin' ? readMacAvailableMemory(overrides.runVmStat) : null);
+    const hostAvailableBytes = overrides.hostAvailableBytes
+        ?? macAvailableBytes
+        ?? os.freemem();
+    const cgroupLimitBytes = overrides.cgroupLimitBytes
+        ?? readNumericFile('/sys/fs/cgroup/memory.max', readFile)
+        ?? readNumericFile('/sys/fs/cgroup/memory/memory.limit_in_bytes', readFile);
+    const cgroupUsedBytes = overrides.cgroupUsedBytes
+        ?? readNumericFile('/sys/fs/cgroup/memory.current', readFile)
+        ?? readNumericFile('/sys/fs/cgroup/memory/memory.usage_in_bytes', readFile);
+    const effectiveTotalBytes = cgroupLimitBytes && cgroupLimitBytes < hostTotalBytes ? cgroupLimitBytes : hostTotalBytes;
+    const cgroupAvailableBytes = cgroupLimitBytes && cgroupUsedBytes !== null ? Math.max(0, cgroupLimitBytes - cgroupUsedBytes) : null;
+    const effectiveAvailableBytes = cgroupAvailableBytes === null ? hostAvailableBytes : Math.min(hostAvailableBytes, cgroupAvailableBytes);
+    return {
+        totalMb: effectiveTotalBytes / (1024 * 1024),
+        availableMb: effectiveAvailableBytes / (1024 * 1024),
+        cgroupLimitMb: cgroupLimitBytes ? cgroupLimitBytes / (1024 * 1024) : null,
+        swapQualified: false
+    };
+}
+
+async function probeNvidia() {
+    try {
+        const { stdout } = await execFileAsync('nvidia-smi', [
+            '--query-gpu=memory.total,memory.free',
+            '--format=csv,noheader,nounits'
+        ], { timeout: 1500, maxBuffer: 64 * 1024 });
+        const devices = stdout.trim().split(/\r?\n/).map((line) => {
+            const [totalMb, availableMb] = line.split(',').map((value) => Number(value.trim()));
+            return { totalMb, availableMb };
+        }).filter((item) => Number.isFinite(item.totalMb) && Number.isFinite(item.availableMb));
+        if (!devices.length) return null;
+        return devices.reduce((best, current) => current.availableMb > best.availableMb ? current : best);
+    } catch {
+        return null;
+    }
+}
+
+async function probeOnnxBackends() {
+    try {
+        const ort = require('onnxruntime-node');
+        const backends = await ort.listSupportedBackends();
+        return backends.filter((item) => item.bundled).map((item) => item.name);
+    } catch {
+        return ['cpu'];
+    }
+}
+
+async function getResourceSnapshot({ skipCompanion = false } = {}) {
+    const memory = getMemorySnapshot();
+    const [nvidia, backends, companion] = await Promise.all([
+        probeNvidia(),
+        probeOnnxBackends(),
+        skipCompanion ? Promise.resolve(null) : probeCompanion()
+    ]);
+    const accelerators = [];
+    if (nvidia) accelerators.push({ type: 'cuda', ...nvidia });
+    if (globalThis.navigator?.gpu) {
+        accelerators.push({ type: 'webgpu', totalMb: null, availableMb: null });
+    }
+    if (process.platform === 'darwin' && backends.includes('coreml')) {
+        accelerators.push({ type: 'coreml', totalMb: memory.totalMb, availableMb: memory.availableMb });
+    }
+    if (companion) {
+        accelerators.push({
+            type: 'companion',
+            totalMb: companion.memory.totalMb,
+            availableMb: companion.memory.availableMb,
+            backend: companion.backend,
+            activeTier: companion.activeTier || null
+        });
+    }
+    return { memory, accelerators, onnxBackends: backends, companion };
+}
+
+module.exports = {
+    readNumericFile,
+    parseMacAvailableMemory,
+    readMacAvailableMemory,
+    getMemorySnapshot,
+    probeNvidia,
+    probeOnnxBackends,
+    getResourceSnapshot
+};