@viralspin/mcp 0.4.0 → 0.5.0

package/dist/organizer/scan.js

@@ -0,0 +1,331 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pairLive = pairLive;
+exports.walkAsync = walkAsync;
+exports.walk = walk;
+exports.organizeScan = organizeScan;
+exports.makeThumbsFor = makeThumbsFor;
+/**
+ * Scan a folder tree (read-only) and propose how to organize it. Reports progress as it goes (the web animation follows it). Nothing is moved here:
+ * applying is a separate, confirmed step (plan.ts applyMoves).
+ */
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const plan_1 = require("./plan");
+const images_1 = require("./images");
+const topics_1 = require("./topics");
+/**
+ * Live Photos: a still and a short clip with the same name in the same folder (IMG_1234.HEIC + IMG_1234.MOV) are ONE moment. The clip rides on the still
+ * (`live`) instead of counting as a second, separate video.
+ */
+function pairLive(items) {
+    const key = (it) => it.rel.slice(0, it.rel.length - path_1.default.extname(it.rel).length).toLowerCase();
+    const stills = new Map(items.filter((it) => it.kind === "image").map((it) => [key(it), it]));
+    const out = [];
+    for (const it of items) {
+        const still = it.kind === "video" ? stills.get(key(it)) : undefined;
+        if (still && it.size < 40000000) {
+            still.live = it.rel;
+            continue;
+        } // a Live Photo clip is a few seconds; a long video with the same name is its own
+        out.push(it);
+    }
+    return out;
+}
+/** walk(), without blocking and with the count so far every few hundred files: a big folder takes a minute to list. */
+async function walkAsync(root, max, onCount) {
+    const out = [];
+    const stack = [root];
+    let told = 0;
+    while (stack.length && out.length < max) {
+        const dir = stack.pop();
+        let ents;
+        try {
+            ents = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        const files = [];
+        for (const e of ents) {
+            const p = path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (e.name !== plan_1.ORGANIZED_DIR && !e.name.startsWith("."))
+                    stack.push(p);
+                continue;
+            }
+            const kind = (0, plan_1.kindOf)(e.name);
+            if (kind)
+                files.push([p, kind]);
+        }
+        for (let k = 0; k < files.length && out.length < max; k += 64) {
+            const sts = await Promise.all(files.slice(k, k + 64).map(([p]) => fs_1.default.promises.stat(p).catch(() => null)));
+            sts.forEach((st, j) => { const [p, kind] = files[k + j]; if (st && out.length < max)
+                out.push({ rel: path_1.default.relative(root, p), kind, size: st.size, mtime: st.mtimeMs }); });
+            if (out.length - told >= 250) {
+                told = out.length;
+                onCount(told);
+            }
+        }
+    }
+    return out.sort((a, b) => a.rel.localeCompare(b.rel));
+}
+function walk(root, max = 10000) {
+    const out = [];
+    const stack = [root];
+    while (stack.length && out.length < max) {
+        const dir = stack.pop();
+        let ents;
+        try {
+            ents = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of ents) {
+            const p = path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                if (e.name !== plan_1.ORGANIZED_DIR && !e.name.startsWith("."))
+                    stack.push(p);
+                continue;
+            }
+            const kind = (0, plan_1.kindOf)(e.name);
+            if (!kind || out.length >= max)
+                continue;
+            try {
+                const st = fs_1.default.statSync(p);
+                out.push({ rel: path_1.default.relative(root, p), kind, size: st.size, mtime: st.mtimeMs });
+            }
+            catch { /* unreadable */ }
+        }
+    }
+    return out.sort((a, b) => a.rel.localeCompare(b.rel));
+}
+/**
+ * An exact-copy fingerprint without reading whole files: the size plus the first, middle and last 256 KB. Only files of the same size are compared,
+ * and two different photos or clips that also agree on those 768 KB do not happen in a camera roll; hashing every byte of 2,700 phone videos took
+ * hours (2026-10-31).
+ */
+const SAMPLE = 256 * 1024;
+const sha1 = async (file) => {
+    const fh = await fs_1.default.promises.open(file, "r");
+    try {
+        const { size } = await fh.stat();
+        const h = crypto_1.default.createHash("sha1").update(String(size));
+        for (const at of size <= SAMPLE * 3 ? [0] : [0, Math.floor(size / 2 - SAMPLE / 2), size - SAMPLE]) {
+            const buf = Buffer.alloc(Math.min(size <= SAMPLE * 3 ? size : SAMPLE, size));
+            const { bytesRead } = await fh.read(buf, 0, buf.length, at);
+            h.update(buf.subarray(0, bytesRead));
+        }
+        return h.digest("hex");
+    }
+    finally {
+        await fh.close();
+    }
+};
+async function pool(n, list, fn) {
+    let k = 0;
+    await Promise.all(Array.from({ length: Math.min(n, list.length) }, async () => { while (k < list.length) {
+        const i = k++;
+        await fn(list[i], i);
+    } }));
+}
+/** The local vision model lives in the engine (not in the npm package); without it pictures stay untagged and topic buckets fall back to "Unsorted". */
+async function visionAnalyzer() {
+    try {
+        const { ENGINE_DIR } = await Promise.resolve().then(() => __importStar(require("../engine")));
+        const url = (0, url_1.pathToFileURL)(path_1.default.join(ENGINE_DIR, "gemini.mjs")).href;
+        return ((await new Function("u", "return import(u)")(url)).analyzeFrame) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function organizeScan(root, o = {}) {
+    const { by: asked = "folder", vision = false, thumbs = "", max = 100000, labels: custom = [], onProgress = () => { } } = o;
+    if (!fs_1.default.existsSync(root) || !fs_1.default.statSync(root).isDirectory())
+        throw new Error(`folder not found: ${root}`);
+    const items = pairLive(await walkAsync(root, max, (n) => onProgress({ phase: "counting", done: n })));
+    onProgress({ phase: "found", total: items.length });
+    const imgs = items.map((_, i) => i).filter((i) => items[i].kind === "image");
+    const t0 = Date.now();
+    let done = 0;
+    await pool(6, imgs, async (i) => {
+        items[i].dhash = (await (0, images_1.dhash)(path_1.default.join(root, items[i].rel))) || undefined;
+        items[i].month = (await (0, images_1.takenMonth)(path_1.default.join(root, items[i].rel))) || undefined;
+        // the preview now, while the picture is being read anyway: the web page builds its pile from these as they land
+        if (thumbs) {
+            try {
+                fs_1.default.mkdirSync(thumbs, { recursive: true });
+                const dst = path_1.default.join(thumbs, `${i}.jpg`);
+                if (await (0, images_1.makeThumb)(path_1.default.join(root, items[i].rel), "image", dst)) {
+                    items[i].thumb = dst;
+                    o.onThumb?.(dst);
+                }
+            }
+            catch { /* the thumbs pass tries again */ }
+        }
+        if (++done % 10 === 0 || done === imgs.length)
+            onProgress({ phase: "reading", done, total: imgs.length, etaMs: Math.round(((Date.now() - t0) / done) * (imgs.length - done)) });
+    });
+    // exact copies after the pictures are read (it reads whole files, slow on big videos; doing it first left the page with nothing to show):
+    // a content hash only where two files share a size
+    const bySize = new Map();
+    items.forEach((it, i) => bySize.set(it.size, [...(bySize.get(it.size) || []), i]));
+    const same = [...bySize.values()].filter((v) => v.length > 1).flat();
+    let h = 0;
+    const th = Date.now();
+    await pool(4, same, async (i) => { try {
+        items[i].hash = await sha1(path_1.default.join(root, items[i].rel));
+    }
+    catch { /* skip */ } if (++h % 25 === 0 || h === same.length)
+        onProgress({ phase: "hashing", done: h, total: same.length, etaMs: Math.round(((Date.now() - th) / h) * (same.length - h)) }); });
+    for (const it of items)
+        if (!it.month) {
+            const d = new Date(it.mtime);
+            it.month = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+        }
+    (0, plan_1.markDuplicates)(items);
+    // topic buckets: the on-device CLIP model first (private, no key), the engine's vision model when that is all there is, else by folder
+    let by = asked;
+    if (asked === "topic") {
+        const todo = items.map((_, i) => i).filter((i) => items[i].dupOf === undefined);
+        const set = (0, topics_1.labelSet)(custom);
+        const clf = await (0, topics_1.labeller)(set);
+        if (clf) {
+            const t2 = Date.now();
+            let v = 0;
+            const found = items.map(() => undefined);
+            // the card a picture will most likely land on (its label's group, or the creator's own label), for the page's live deal
+            const card = new Map(set.names.map((nm, j) => [nm, set.custom.has(nm) ? nm : set.groups[j]]));
+            onProgress({ phase: "looking", done: 0, total: todo.length });
+            await pool(2, todo, async (i) => {
+                try {
+                    const rgb = await (0, images_1.rgb224)(path_1.default.join(root, items[i].rel), items[i].kind);
+                    if (rgb)
+                        found[i] = await clf(rgb, 224, 224);
+                }
+                catch { /* leave it for Other */ }
+                if (!found[i])
+                    found[i] = { tags: [], best: null };
+                const best = found[i]?.best;
+                o.onLabel?.(i, best ? card.get(best) ?? best : "Other");
+                if (++v % 10 === 0 || v === todo.length)
+                    onProgress({ phase: "looking", done: v, total: todo.length, etaMs: Math.round(((Date.now() - t2) / v) * (todo.length - v)) });
+            });
+            // the bucket is the fine label when enough pictures share it (or the creator asked for it), else its broader group; the labels stay as tags
+            // keep every picture's embedding next to the plan (float32, one row per item): labels added later are a dot product, not a rescan
+            if (o.embFile) {
+                const d = found.find((f) => f?.emb)?.emb?.length ?? 512;
+                const buf = new Float32Array(items.length * d);
+                found.forEach((f, i) => { if (f?.emb)
+                    buf.set(f.emb, i * d); });
+                try {
+                    fs_1.default.writeFileSync(o.embFile, Buffer.from(buf.buffer));
+                }
+                catch { /* relabelling will say it needs a rescan */ }
+                for (const f of found)
+                    if (f)
+                        delete f.emb;
+            }
+            const bucket = (0, topics_1.bucketFor)(found, set);
+            for (const i of todo) {
+                items[i].topic = bucket[i] ?? "Other";
+                items[i].tags = found[i]?.tags ?? [];
+            }
+        }
+        else {
+            const analyze = vision ? await visionAnalyzer() : null;
+            if (analyze) {
+                let v = 0;
+                await pool(2, todo.filter((i) => items[i].kind === "image"), async (i) => {
+                    try {
+                        const a = await analyze(path_1.default.join(root, items[i].rel), "image");
+                        items[i].subject = a.subject || "";
+                        items[i].tags = a.keywords || [];
+                    }
+                    catch { /* leave untagged */ }
+                    if (++v % 5 === 0 || v === todo.length)
+                        onProgress({ phase: "looking", done: v, total: todo.length });
+                });
+            }
+            else
+                by = "folder"; // nothing here can tell what a picture shows
+        }
+    }
+    // with the picture model, labels already fold small subjects into their group; folding again would swallow a label the creator asked for
+    const buckets = (0, plan_1.planBuckets)(items, { by, minBucket: by === "topic" && items.some((it) => it.tags?.length) ? 1 : 3 });
+    if (thumbs) {
+        fs_1.default.mkdirSync(thumbs, { recursive: true });
+        let n = 0;
+        const t1 = Date.now();
+        await pool(4, items, async (it, i) => {
+            const dst = path_1.default.join(thumbs, `${i}.jpg`);
+            if (it.dupOf === undefined && !it.thumb && (await (0, images_1.makeThumb)(path_1.default.join(root, it.rel), it.kind, dst)))
+                it.thumb = dst;
+            if (it.dupOf !== undefined && it.thumb) {
+                try {
+                    fs_1.default.rmSync(it.thumb, { force: true });
+                }
+                catch { /* ignore */ }
+                delete it.thumb;
+            }
+            if (++n % 10 === 0 || n === items.length)
+                onProgress({ phase: "thumbs", done: n, total: items.length, etaMs: Math.round(((Date.now() - t1) / n) * (items.length - n)) });
+        });
+    }
+    const id = crypto_1.default.randomBytes(4).toString("hex");
+    const plan = { id, root, createdAt: new Date().toISOString(), by, vision, labels: custom, totals: (0, plan_1.summarize)(items, buckets), items, buckets, moves: (0, plan_1.planMoves)(root, items, buckets) };
+    onProgress({ phase: "done" });
+    return plan;
+}
+/** Thumbnails for a saved plan's non-duplicate files (the opt-in My Story upload). Rewrites the plan file with each item's `thumb`. */
+async function makeThumbsFor(planFile, dir) {
+    const plan = JSON.parse(fs_1.default.readFileSync(planFile, "utf8"));
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    await pool(4, plan.items, async (it, i) => {
+        const dst = path_1.default.join(dir, `${i}.jpg`);
+        if (it.dupOf === undefined && (fs_1.default.existsSync(dst) || (await (0, images_1.makeThumb)(path_1.default.join(plan.root, it.rel), it.kind, dst))))
+            it.thumb = dst;
+    });
+    fs_1.default.writeFileSync(planFile, JSON.stringify(plan));
+    return plan;
+}

package/dist/organizer/topics.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUSTOM_MIN = exports.OTHER = exports.VOCAB = void 0;
+exports.labelSet = labelSet;
+exports.pickLabels = pickLabels;
+exports.bucketFor = bucketFor;
+exports.labelsFromEmbedding = labelsFromEmbedding;
+exports.textEmbeddings = textEmbeddings;
+exports.labeller = labeller;
+/**
+ * Labels ON THIS COMPUTER: CLIP (a small open image model, ~150 MB, downloaded once and cached) compares each picture with a vocabulary of everyday
+ * subjects plus any labels the creator typed ("tennis", "kids at the beach"). Nothing leaves the computer.
+ *
+ * Every picture gets up to three labels (its tags, for search and filters) and one bucket. The bucket is the fine label ("Tennis") when enough
+ * pictures share it, or when the creator asked for it; otherwise the broader group it belongs to ("Sport & wellness"), the reel's cards. So labels
+ * appear as the folder needs them rather than from a fixed list, and a one-off subject never gets a card of its own.
+ *
+ * The text side is embedded once per scan; each picture is one vision pass and a dot product, so 60 labels cost the same as 14.
+ * Optional: when @huggingface/transformers (or sharp, which makes its input) is missing, labeller() returns null and the scan sorts by folder.
+ */
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+/** [label, what CLIP is asked, the broader group it falls back to]. The groups are the reel's cards. */
+exports.VOCAB = [
+    ["Selfies", "a selfie of a person looking at the camera", "Selfies & talking"],
+    ["Mirror selfies", "a mirror selfie", "Selfies & talking"],
+    ["Talking to camera", "a person talking to the camera", "Selfies & talking"],
+    ["Group photos", "a group of friends posing together", "Events"],
+    ["Outfits", "a person showing an outfit or clothes", "Outfits"],
+    ["Shoes & accessories", "shoes, a bag or jewellery", "Outfits"],
+    ["Swimwear", "a person in a swimsuit or bikini", "Outfits"],
+    ["Rooftops & terraces", "a rooftop terrace with a city view", "Travel & vibe"],
+    ["Food", "a plate of food", "Food & cafés"],
+    ["Coffee & drinks", "a coffee or a drink", "Food & cafés"],
+    ["Desserts", "a cake or a dessert", "Food & cafés"],
+    ["Restaurants", "people eating at a restaurant", "Food & cafés"],
+    ["City streets", "a city street", "Travel & vibe"],
+    ["Landmarks", "a famous landmark or monument", "Travel & vibe"],
+    ["Airports & flights", "an airport or the view from an airplane", "Travel & vibe"],
+    ["Hotels", "a hotel room or a resort", "Travel & vibe"],
+    ["Night lights", "a city at night", "Travel & vibe"],
+    ["Beach", "a beach", "Nature"],
+    ["Mountains", "mountains or hiking", "Nature"],
+    ["Sunsets", "a sunset or sunrise", "Nature"],
+    ["Snow", "snow and winter", "Nature"],
+    ["Flowers & gardens", "flowers or a garden", "Nature"],
+    ["Parks", "a park with trees and grass", "Nature"],
+    ["Water & boats", "a lake, a river or a boat", "Nature"],
+    ["Home interiors", "a living room or a bedroom", "Aesthetic spaces"],
+    ["Architecture", "a building or architecture", "Aesthetic spaces"],
+    ["Tennis", "a person playing tennis or a tennis court", "Sport & wellness"],
+    ["Golf", "golf", "Sport & wellness"],
+    ["Running", "a person running", "Sport & wellness"],
+    ["Gym", "a gym or lifting weights", "Sport & wellness"],
+    ["Yoga", "yoga or stretching", "Sport & wellness"],
+    ["Swimming", "a swimming pool or swimming", "Sport & wellness"],
+    ["Basketball", "basketball", "Sport & wellness"],
+    ["Soccer", "soccer or football", "Sport & wellness"],
+    ["Cycling", "a bicycle or cycling", "Sport & wellness"],
+    ["Skiing", "skiing or snowboarding", "Sport & wellness"],
+    ["Concerts", "a concert or live music", "Music & hobby"],
+    ["Instruments", "a musical instrument", "Music & hobby"],
+    ["Art & crafts", "a painting, drawing or crafts", "Music & hobby"],
+    ["Games", "video games or board games", "Music & hobby"],
+    ["Desk & laptop", "a laptop on a desk", "Work from home"],
+    ["Meetings & talks", "a meeting, a presentation or someone on stage", "Work from home"],
+    ["Whiteboards & slides", "a whiteboard or a presentation slide", "Text & captions"],
+    ["Screenshots", "a screenshot of a phone or computer screen", "Text & captions"],
+    ["Documents & receipts", "a document, a receipt or a printed page", "Text & captions"],
+    ["Charts", "a chart or a graph", "Text & captions"],
+    ["Dogs", "a dog", "Pets"],
+    ["Cats", "a cat", "Pets"],
+    ["Babies", "a baby", "Family"],
+    ["Kids", "children playing", "Family"],
+    ["Family", "a family together", "Family"],
+    ["Weddings", "a wedding", "Events"],
+    ["Birthdays", "a birthday party or a cake with candles", "Events"],
+    ["Parties", "a party with people", "Events"],
+    ["Holidays", "a christmas tree or holiday decorations", "Events"],
+    ["Cars", "a car", "Products"],
+    ["Products", "a product photo of an object", "Products"],
+    ["Gadgets", "a phone, a camera or a gadget", "Products"],
+    ["Shopping", "a shop or shopping", "Products"],
+];
+exports.OTHER = "Other";
+const MODEL = "Xenova/clip-vit-base-patch32";
+/** a label counts for a picture when it is at least this share of the softmax and within this ratio of the best one; below BEST_MIN the picture is "Other" */
+const TAG_MIN = 0.08, TAG_RATIO = 0.35, BEST_MIN = 0.12;
+/**
+ * The cosine a picture needs with a creator's own label (CLIP ViT-B/32, "a photo of …"). Measured on Allen's 3,911 pictures for "tennis": the top
+ * 40 (cos >= 0.286) were all tennis, ranks 60-100 (0.267-0.248) rooftop and pool shots; 0.27 keeps the courts and drops the rest.
+ */
+exports.CUSTOM_MIN = 0.27;
+/** The vocabulary plus the creator's own labels (theirs win when the name matches; each is its own card, never folded into a group). */
+function labelSet(custom = []) {
+    const mine = [...new Set(custom.map((s) => String(s).trim().slice(0, 40)).filter(Boolean))];
+    const lower = new Set(mine.map((s) => s.toLowerCase()));
+    const base = exports.VOCAB.filter(([n]) => !lower.has(n.toLowerCase()));
+    const titled = mine.map((s) => s[0].toUpperCase() + s.slice(1));
+    // "tennis" typed by the creator keeps the built-in, descriptive prompt ("a person playing tennis or a tennis court"): the bare word matched
+    // rooftops, pools and sporty outfits on Allen's folder
+    const known = new Map(exports.VOCAB.map(([n, p]) => [n.toLowerCase(), p]));
+    return {
+        names: [...titled, ...base.map(([n]) => n)],
+        prompts: [...mine.map((m) => known.get(m.toLowerCase()) ?? m), ...base.map(([, p]) => p)],
+        groups: [...titled, ...base.map(([, , g]) => g)],
+        custom: new Set(titled),
+    };
+}
+/** From one picture's softmax over the label set: its tags (best first) and its best label, or none when nothing is clear. */
+function pickLabels(probs, set) {
+    const order = probs.map((p, i) => [p, i]).sort((a, b) => b[0] - a[0]);
+    const top = order[0]?.[0] ?? 0;
+    const tags = order.filter(([p], k) => k < 3 && p >= TAG_MIN && p >= top * TAG_RATIO).map(([, i]) => set.names[i]);
+    return { tags, best: top >= BEST_MIN ? set.names[order[0][1]] : null };
+}
+/**
+ * Buckets from the labels: a fine label gets its own card when the creator asked for it or when enough pictures share it
+ * (at least `min`, default max(6, 2% of the pictures)); otherwise its pictures go to the label's group card.
+ */
+function bucketFor(labels, set, min) {
+    const n = labels.filter(Boolean).length;
+    const need = min ?? Math.max(6, Math.ceil(n * 0.02));
+    const counts = new Map();
+    for (const l of labels)
+        if (l?.best)
+            counts.set(l.best, (counts.get(l.best) ?? 0) + 1);
+    const group = new Map(set.names.map((nm, i) => [nm, set.groups[i]]));
+    return labels.map((l) => {
+        if (!l)
+            return undefined;
+        if (!l.best)
+            return exports.OTHER;
+        if (set.custom.has(l.best) || (counts.get(l.best) ?? 0) >= need)
+            return l.best;
+        return group.get(l.best) ?? exports.OTHER;
+    });
+}
+let model;
+async function loadModel() {
+    // transformers is ESM-only; tsc (CommonJS) would turn a literal import() into require()
+    const esm = new Function("m", "return import(m)");
+    const tf = await esm("@huggingface/transformers");
+    tf.env.cacheDir = path_1.default.join(os_1.default.homedir(), ".viralspin", "models");
+    fs_1.default.mkdirSync(tf.env.cacheDir, { recursive: true });
+    const [tokenizer, text, processor, vision] = await Promise.all([
+        tf.AutoTokenizer.from_pretrained(MODEL),
+        tf.CLIPTextModelWithProjection.from_pretrained(MODEL),
+        tf.AutoProcessor.from_pretrained(MODEL),
+        tf.CLIPVisionModelWithProjection.from_pretrained(MODEL),
+    ]);
+    return { tf, tokenizer, text, processor, vision };
+}
+const unit = (v, off, d) => { let s = 0; for (let i = 0; i < d; i++)
+    s += v[off + i] ** 2; const k = 1 / Math.sqrt(s || 1); return Array.from({ length: d }, (_, i) => v[off + i] * k); };
+/** Labels from a stored picture embedding (unit length) against the label set's text embeddings: the same answer as the scan gave, without the picture. */
+function labelsFromEmbedding(v, T, set) {
+    const cos = T.map((t) => { let d = 0; for (let i = 0; i < t.length; i++)
+        d += t[i] * v[i]; return d; });
+    const logits = cos.map((c) => 100 * c);
+    const mx = Math.max(...logits);
+    const e = logits.map((x) => Math.exp(x - mx));
+    const z = e.reduce((x, y) => x + y, 0);
+    // a label the creator asked for must truly match, not merely beat the other labels: below CUSTOM_MIN it is not offered for this picture
+    const probs = e.map((x, i) => (set.custom.has(set.names[i]) && cos[i] < exports.CUSTOM_MIN ? 0 : x / z));
+    return pickLabels(probs, set);
+}
+/** The label set's text side, embedded once (unit vectors), or null when the model can not run here. */
+async function textEmbeddings(set) {
+    if (!model)
+        model = loadModel().catch(() => null);
+    const m = await model;
+    if (!m)
+        return null;
+    try {
+        const { text_embeds } = await m.text(m.tokenizer(set.prompts.map((p) => `a photo of ${p}`), { padding: true, truncation: true }));
+        const d = text_embeds.dims[1];
+        return set.prompts.map((_, i) => unit(text_embeds.data, i * d, d));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * A labeller for this label set, or null when this install cannot run the model. The model loads once per process (the first run downloads it).
+ * Each answer carries the picture's embedding too: the scan keeps it, so a label added later ("tennis") re-sorts the folder in seconds.
+ */
+async function labeller(set) {
+    const T = await textEmbeddings(set);
+    const m = await model;
+    if (!T || !m)
+        return null;
+    const d = T[0]?.length ?? 512;
+    return async (rgb, w, h) => {
+        const img = new m.tf.RawImage(new Uint8ClampedArray(rgb), w, h, 3);
+        const { image_embeds } = await m.vision(await m.processor(img));
+        const v = unit(image_embeds.data, 0, d);
+        return { ...labelsFromEmbedding(v, T, set), emb: v };
+    };
+}