editmamei 0.17.4 → 0.18.0

package/dist/detection/face-feature-geometry.js

@@ -0,0 +1,180 @@
+import { LANDMARK_GROUPS } from './landmark-spec.js';
+export const FACE_FEATURES = [
+    'face',
+    'skin',
+    'eyes',
+    'left_eye',
+    'right_eye',
+    'brows',
+    'left_brow',
+    'right_brow',
+    'lips',
+    'teeth',
+    'nose',
+    'under_eye',
+    'cheeks',
+];
+function ring(points, indices) {
+    const out = [];
+    for (const i of indices) {
+        const p = points[i];
+        if (p)
+            out.push([p.x, p.y]);
+    }
+    return out;
+}
+export function convexHull(pts) {
+    const uniq = Array.from(new Set(pts.map((p) => `${p[0]},${p[1]}`))).map((s) => s.split(',').map(Number));
+    if (uniq.length <= 2)
+        return uniq;
+    uniq.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+    const lower = [];
+    for (const p of uniq) {
+        while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0)
+            lower.pop();
+        lower.push(p);
+    }
+    const upper = [];
+    for (let i = uniq.length - 1; i >= 0; i--) {
+        const p = uniq[i];
+        while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0)
+            upper.pop();
+        upper.push(p);
+    }
+    lower.pop();
+    upper.pop();
+    return lower.concat(upper);
+}
+function bbox(pts) {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const [x, y] of pts) {
+        if (x < minX)
+            minX = x;
+        if (y < minY)
+            minY = y;
+        if (x > maxX)
+            maxX = x;
+        if (y > maxY)
+            maxY = y;
+    }
+    return [minX, minY, maxX, maxY];
+}
+function underEyeBand(eyeRing, drop = 1.1) {
+    if (eyeRing.length < 3)
+        return null;
+    const [minX, minY, maxX, maxY] = bbox(eyeRing);
+    const h = maxY - minY;
+    if (h <= 0)
+        return null;
+    const top = maxY + h * 0.15;
+    const bottom = maxY + h * (0.15 + drop);
+    return [
+        [minX, top],
+        [maxX, top],
+        [maxX, bottom],
+        [minX, bottom],
+    ];
+}
+function cheekPatch(eyeRing, noseAla, mouthCorner) {
+    if (eyeRing.length < 3 || !noseAla || !mouthCorner)
+        return null;
+    const [minX, , maxX, maxY] = bbox(eyeRing);
+    const outerX = Math.abs(minX - noseAla[0]) > Math.abs(maxX - noseAla[0]) ? minX : maxX;
+    const eyeOuterLow = [outerX, maxY];
+    return convexHull([eyeOuterLow, noseAla, mouthCorner, [noseAla[0], mouthCorner[1]]]);
+}
+function rings(points) {
+    return {
+        faceOval: ring(points, LANDMARK_GROUPS.faceOval),
+        leftEye: ring(points, LANDMARK_GROUPS.leftEye),
+        rightEye: ring(points, LANDMARK_GROUPS.rightEye),
+        leftBrow: convexHull(ring(points, LANDMARK_GROUPS.leftEyebrow)),
+        rightBrow: convexHull(ring(points, LANDMARK_GROUPS.rightEyebrow)),
+        lipsOuter: ring(points, LANDMARK_GROUPS.lipsOuter),
+        lipsInner: ring(points, LANDMARK_GROUPS.lipsInner),
+        nose: convexHull(ring(points, LANDMARK_GROUPS.nose)),
+    };
+}
+function ok(p) {
+    return Array.isArray(p) && p.length >= 3;
+}
+export function buildFeaturePlan(points, feature) {
+    const r = rings(points);
+    const noseAla = points[129] ?? points[358] ?? null;
+    const leftMouthCorner = points[61] ? [points[61].x, points[61].y] : null;
+    const rightMouthCorner = points[291] ? [points[291].x, points[291].y] : null;
+    const ala = noseAla ? [noseAla.x, noseAla.y] : null;
+    switch (feature) {
+        case 'face':
+            return ok(r.faceOval) ? [{ points: r.faceOval, op: 'replace' }] : null;
+        case 'skin': {
+            if (!ok(r.faceOval))
+                return null;
+            const plan = [{ points: r.faceOval, op: 'replace' }];
+            for (const hole of [r.leftEye, r.rightEye, r.leftBrow, r.rightBrow, r.lipsOuter]) {
+                if (ok(hole))
+                    plan.push({ points: hole, op: 'subtract' });
+            }
+            return plan;
+        }
+        case 'left_eye':
+            return ok(r.leftEye) ? [{ points: r.leftEye, op: 'replace' }] : null;
+        case 'right_eye':
+            return ok(r.rightEye) ? [{ points: r.rightEye, op: 'replace' }] : null;
+        case 'eyes': {
+            const plan = [];
+            if (ok(r.leftEye))
+                plan.push({ points: r.leftEye, op: 'replace' });
+            if (ok(r.rightEye))
+                plan.push({ points: r.rightEye, op: plan.length ? 'add' : 'replace' });
+            return plan.length ? plan : null;
+        }
+        case 'left_brow':
+            return ok(r.leftBrow) ? [{ points: r.leftBrow, op: 'replace' }] : null;
+        case 'right_brow':
+            return ok(r.rightBrow) ? [{ points: r.rightBrow, op: 'replace' }] : null;
+        case 'brows': {
+            const plan = [];
+            if (ok(r.leftBrow))
+                plan.push({ points: r.leftBrow, op: 'replace' });
+            if (ok(r.rightBrow))
+                plan.push({ points: r.rightBrow, op: plan.length ? 'add' : 'replace' });
+            return plan.length ? plan : null;
+        }
+        case 'lips': {
+            if (!ok(r.lipsOuter))
+                return null;
+            const plan = [{ points: r.lipsOuter, op: 'replace' }];
+            if (ok(r.lipsInner))
+                plan.push({ points: r.lipsInner, op: 'subtract' });
+            return plan;
+        }
+        case 'teeth':
+            return ok(r.lipsInner) ? [{ points: r.lipsInner, op: 'replace' }] : null;
+        case 'nose':
+            return ok(r.nose) ? [{ points: r.nose, op: 'replace' }] : null;
+        case 'under_eye': {
+            const plan = [];
+            const lb = underEyeBand(r.leftEye);
+            const rb = underEyeBand(r.rightEye);
+            if (ok(lb))
+                plan.push({ points: lb, op: 'replace' });
+            if (ok(rb))
+                plan.push({ points: rb, op: plan.length ? 'add' : 'replace' });
+            return plan.length ? plan : null;
+        }
+        case 'cheeks': {
+            const plan = [];
+            const lc = cheekPatch(r.leftEye, ala, leftMouthCorner);
+            const rc = cheekPatch(r.rightEye, ala, rightMouthCorner);
+            if (ok(lc))
+                plan.push({ points: lc, op: 'replace' });
+            if (ok(rc))
+                plan.push({ points: rc, op: plan.length ? 'add' : 'replace' });
+            return plan.length ? plan : null;
+        }
+        default:
+            return null;
+    }
+}

package/dist/detection/geometry.js

@@ -0,0 +1,35 @@
+export function iou(a, b) {
+    const x1 = Math.max(a[0], b[0]);
+    const y1 = Math.max(a[1], b[1]);
+    const x2 = Math.min(a[2], b[2]);
+    const y2 = Math.min(a[3], b[3]);
+    const inter = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+    const ua = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter;
+    return inter / (ua + 1e-9);
+}
+export function greedyNms(items, iouThreshold, sameGroup) {
+    const keep = [];
+    for (const item of items) {
+        const overlaps = keep.some((k) => (!sameGroup || sameGroup(k, item)) && iou(k.bbox, item.bbox) >= iouThreshold);
+        if (!overlaps)
+            keep.push(item);
+    }
+    return keep;
+}
+export function resizeToCHW(img, outW, outH, normalize) {
+    const { width: w, height: h, data } = img;
+    const out = new Float32Array(3 * outH * outW);
+    const plane = outH * outW;
+    for (let y = 0; y < outH; y++) {
+        const sy = Math.min(h - 1, Math.floor((y * h) / outH));
+        for (let x = 0; x < outW; x++) {
+            const sx = Math.min(w - 1, Math.floor((x * w) / outW));
+            const si = (sy * w + sx) * 4;
+            const di = y * outW + x;
+            out[di] = normalize(data[si]);
+            out[plane + di] = normalize(data[si + 1]);
+            out[2 * plane + di] = normalize(data[si + 2]);
+        }
+    }
+    return out;
+}

package/dist/detection/landmark-detection-client.js

@@ -0,0 +1,38 @@
+import { decodeJpeg as realDecodeJpeg } from './runtime.js';
+import { detectLandmarks as realDetectLandmarks, } from './landmark-detector.js';
+import { OnnxDetectionClient, } from './detection-client.js';
+const LANDMARK_BACKEND = 'facemesh-468';
+export class OnnxLandmarkDetectionClient {
+    base;
+    opts;
+    detectLandmarks;
+    decodeJpeg;
+    constructor(base = new OnnxDetectionClient(), opts = {}, deps = {}) {
+        this.base = base;
+        this.opts = opts;
+        this.detectLandmarks = deps.detectLandmarks ?? realDetectLandmarks;
+        this.decodeJpeg = deps.decodeJpeg ?? realDecodeJpeg;
+    }
+    async detect(imagePath, opts) {
+        const result = await this.base.detect(imagePath, opts);
+        if (!opts.faces || !result.faces || result.faces.length === 0)
+            return result;
+        const img = this.decodeJpeg(imagePath);
+        const minScore = this.opts.minScore ?? 0.5;
+        const lmOpts = { margin: this.opts.margin };
+        for (const face of result.faces) {
+            try {
+                const mesh = await this.detectLandmarks(img, face.bbox, lmOpts);
+                if (mesh.score >= minScore) {
+                    face.features = { points: mesh.points, score: mesh.score, backend: LANDMARK_BACKEND };
+                }
+            }
+            catch {
+            }
+        }
+        result.backends.faces = result.backends.faces
+            ? `${result.backends.faces}+${LANDMARK_BACKEND}`
+            : LANDMARK_BACKEND;
+        return result;
+    }
+}

package/dist/detection/landmark-detector.js

@@ -0,0 +1,63 @@
+import { loadModel, resolveModelPath, ort } from './runtime.js';
+import { LANDMARK_COUNT, MODEL_INPUT_SIZE } from './landmark-spec.js';
+const MODEL_FILE = 'pro/face_mesh_468.onnx';
+const DEFAULT_MARGIN = 0.25;
+export function squareCrop(box, imgW, imgH, margin) {
+    const [x1, y1, x2, y2] = box;
+    const bw = Math.max(0, x2 - x1);
+    const bh = Math.max(0, y2 - y1);
+    const cx = x1 + bw / 2;
+    const cy = y1 + bh / 2;
+    let side = Math.max(bw, bh) * (1 + 2 * margin);
+    side = Math.min(side, imgW, imgH);
+    let x0 = cx - side / 2;
+    let y0 = cy - side / 2;
+    x0 = Math.max(0, Math.min(x0, imgW - side));
+    y0 = Math.max(0, Math.min(y0, imgH - side));
+    return { x0, y0, side };
+}
+export function cropResizeToCHW(img, crop, out) {
+    const { width: w, height: h, data } = img;
+    const tensor = new Float32Array(3 * out * out);
+    const plane = out * out;
+    for (let oy = 0; oy < out; oy++) {
+        const syf = crop.y0 + ((oy + 0.5) / out) * crop.side;
+        const sy = Math.min(h - 1, Math.max(0, Math.floor(syf)));
+        for (let ox = 0; ox < out; ox++) {
+            const sxf = crop.x0 + ((ox + 0.5) / out) * crop.side;
+            const sx = Math.min(w - 1, Math.max(0, Math.floor(sxf)));
+            const si = (sy * w + sx) * 4;
+            const di = oy * out + ox;
+            tensor[di] = data[si] / 255;
+            tensor[plane + di] = data[si + 1] / 255;
+            tensor[2 * plane + di] = data[si + 2] / 255;
+        }
+    }
+    return tensor;
+}
+export function mapLandmarks(rawFlat, crop) {
+    const points = new Array(LANDMARK_COUNT);
+    for (let i = 0; i < LANDMARK_COUNT; i++) {
+        points[i] = {
+            x: crop.x0 + rawFlat[i * 3] * crop.side,
+            y: crop.y0 + rawFlat[i * 3 + 1] * crop.side,
+            z: rawFlat[i * 3 + 2] * crop.side,
+        };
+    }
+    return points;
+}
+export async function detectLandmarks(img, box, opts = {}) {
+    const margin = opts.margin ?? DEFAULT_MARGIN;
+    const crop = squareCrop(box, img.width, img.height, margin);
+    if (crop.side <= 0)
+        throw new Error('degenerate face box for landmark crop');
+    const session = await loadModel(resolveModelPath(MODEL_FILE));
+    const input = cropResizeToCHW(img, crop, MODEL_INPUT_SIZE);
+    const feeds = {
+        image: new ort.Tensor('float32', input, [1, 3, MODEL_INPUT_SIZE, MODEL_INPUT_SIZE]),
+    };
+    const out = await session.run(feeds);
+    const score = out.scores.data[0] ?? 0;
+    const landmarks = out.landmarks.data;
+    return { score, points: mapLandmarks(landmarks, crop) };
+}

package/dist/detection/landmark-spec.js

@@ -0,0 +1,29 @@
+export const LANDMARK_COUNT = 468;
+export const MODEL_INPUT_SIZE = 192;
+export const LANDMARK_GROUPS = {
+    faceOval: [
+        10, 338, 297, 332, 284, 251, 389, 356, 454, 323, 361, 288, 397, 365, 379, 378, 400, 377, 152,
+        148, 176, 149, 150, 136, 172, 58, 132, 93, 234, 127, 162, 21, 54, 103, 67, 109,
+    ],
+    leftEye: [263, 249, 390, 373, 374, 380, 381, 382, 362, 398, 384, 385, 386, 387, 388, 466],
+    rightEye: [33, 7, 163, 144, 145, 153, 154, 155, 133, 173, 157, 158, 159, 160, 161, 246],
+    leftEyebrow: [276, 283, 282, 295, 285, 300, 293, 334, 296, 336],
+    rightEyebrow: [46, 53, 52, 65, 55, 70, 63, 105, 66, 107],
+    lipsOuter: [
+        61, 146, 91, 181, 84, 17, 314, 405, 321, 375, 291, 409, 270, 269, 267, 0, 37, 39, 40, 185,
+    ],
+    lipsInner: [
+        78, 95, 88, 178, 87, 14, 317, 402, 318, 324, 308, 415, 310, 311, 312, 13, 82, 81, 80, 191,
+    ],
+    nose: [168, 6, 197, 195, 5, 4, 1, 19, 94, 2, 98, 97, 326, 327, 129, 358],
+};
+export const LANDMARK_GROUP_KEYS = Object.keys(LANDMARK_GROUPS);
+export const LANDMARK_ANCHORS = {
+    noseTip: 1,
+    chin: 152,
+    foreheadTop: 10,
+    betweenEyes: 168,
+    upperLipTop: 0,
+    lowerLipBottom: 17,
+};
+export const LANDMARK_ANCHOR_KEYS = Object.keys(LANDMARK_ANCHORS);

package/dist/detection/mesh-face.js

@@ -0,0 +1,36 @@
+export function meshFaces(faces) {
+    const out = [];
+    for (const f of faces) {
+        if (f.features) {
+            out.push({
+                bbox: f.bbox,
+                confidence: f.confidence,
+                score: f.features.score,
+                points: f.features.points,
+            });
+        }
+    }
+    return out;
+}
+const area = (f) => (f.bbox[2] - f.bbox[0]) * (f.bbox[3] - f.bbox[1]);
+export function pickFace(faces, which) {
+    if (faces.length === 0)
+        return undefined;
+    const byLeft = [...faces].sort((a, b) => a.bbox[0] - b.bbox[0]);
+    switch (which) {
+        case 'best':
+            return [...faces].sort((a, b) => b.score - a.score || area(b) - area(a))[0];
+        case 'leftmost':
+            return byLeft[0];
+        case 'rightmost':
+            return byLeft[byLeft.length - 1];
+        case 'largest':
+            return [...faces].sort((a, b) => area(b) - area(a))[0];
+        default: {
+            const idx = Number.parseInt(which, 10);
+            if (String(idx) === which.trim() && idx >= 0 && idx < byLeft.length)
+                return byLeft[idx];
+            return undefined;
+        }
+    }
+}

package/dist/detection/object-detector.js

@@ -0,0 +1,135 @@
+import { loadModel, resolveModelPath, decodeJpeg, ort } from './runtime.js';
+import { greedyNms, resizeToCHW } from './geometry.js';
+const MODEL_FILE = 'dfine-s-coco-quant.onnx';
+const IN_SIZE = 640;
+const NUM_QUERIES = 300;
+const NUM_CLASSES = 80;
+const DEFAULT_THRESHOLD = 0.4;
+const IOU_THRESHOLD = 0.5;
+const DEFAULT_MAX = 50;
+export const COCO_LABELS = [
+    'person',
+    'bicycle',
+    'car',
+    'motorbike',
+    'aeroplane',
+    'bus',
+    'train',
+    'truck',
+    'boat',
+    'traffic light',
+    'fire hydrant',
+    'stop sign',
+    'parking meter',
+    'bench',
+    'bird',
+    'cat',
+    'dog',
+    'horse',
+    'sheep',
+    'cow',
+    'elephant',
+    'bear',
+    'zebra',
+    'giraffe',
+    'backpack',
+    'umbrella',
+    'handbag',
+    'tie',
+    'suitcase',
+    'frisbee',
+    'skis',
+    'snowboard',
+    'sports ball',
+    'kite',
+    'baseball bat',
+    'baseball glove',
+    'skateboard',
+    'surfboard',
+    'tennis racket',
+    'bottle',
+    'wine glass',
+    'cup',
+    'fork',
+    'knife',
+    'spoon',
+    'bowl',
+    'banana',
+    'apple',
+    'sandwich',
+    'orange',
+    'broccoli',
+    'carrot',
+    'hot dog',
+    'pizza',
+    'donut',
+    'cake',
+    'chair',
+    'sofa',
+    'pottedplant',
+    'bed',
+    'diningtable',
+    'toilet',
+    'tvmonitor',
+    'laptop',
+    'mouse',
+    'remote',
+    'keyboard',
+    'cell phone',
+    'microwave',
+    'oven',
+    'toaster',
+    'sink',
+    'refrigerator',
+    'book',
+    'clock',
+    'vase',
+    'scissors',
+    'teddy bear',
+    'hair drier',
+    'toothbrush',
+];
+const sigmoid = (x) => 1 / (1 + Math.exp(-x));
+export async function detectObjects(imagePath, opts = {}) {
+    const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+    const maxObjects = opts.maxObjects ?? DEFAULT_MAX;
+    const img = decodeJpeg(imagePath);
+    const session = await loadModel(resolveModelPath(MODEL_FILE));
+    const input = resizeToCHW(img, IN_SIZE, IN_SIZE, (v) => v / 255);
+    const feeds = { pixel_values: new ort.Tensor('float32', input, [1, 3, IN_SIZE, IN_SIZE]) };
+    const out = await session.run(feeds);
+    const logits = out.logits.data;
+    const boxes = out.pred_boxes.data;
+    const cand = [];
+    for (let q = 0; q < NUM_QUERIES; q++) {
+        let bestC = -1;
+        let bestS = 0;
+        for (let c = 0; c < NUM_CLASSES; c++) {
+            const s = sigmoid(logits[q * NUM_CLASSES + c]);
+            if (s > bestS) {
+                bestS = s;
+                bestC = c;
+            }
+        }
+        if (bestS >= threshold) {
+            const cx = boxes[q * 4];
+            const cy = boxes[q * 4 + 1];
+            const bw = boxes[q * 4 + 2];
+            const bh = boxes[q * 4 + 3];
+            cand.push({
+                label: COCO_LABELS[bestC],
+                class_id: bestC,
+                confidence: bestS,
+                bbox: [
+                    (cx - bw / 2) * img.width,
+                    (cy - bh / 2) * img.height,
+                    (cx + bw / 2) * img.width,
+                    (cy + bh / 2) * img.height,
+                ],
+            });
+        }
+    }
+    cand.sort((a, b) => b.confidence - a.confidence);
+    const kept = greedyNms(cand, IOU_THRESHOLD, (a, b) => a.label === b.label);
+    return { width: img.width, height: img.height, objects: kept.slice(0, maxObjects) };
+}

package/dist/detection/runtime.js

@@ -0,0 +1,46 @@
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { decode } from 'jpeg-js';
+import { readFileSync } from 'node:fs';
+import * as ort from 'onnxruntime-web';
+let configured = false;
+function configureOrt() {
+    if (configured)
+        return;
+    const require = createRequire(import.meta.url);
+    const ortDist = dirname(require.resolve('onnxruntime-web'));
+    ort.env.wasm.wasmPaths = pathToFileURL(join(ortDist, '/')).href;
+    ort.env.wasm.numThreads = 1;
+    ort.env.logLevel = 'error';
+    configured = true;
+}
+const sessions = new Map();
+export function loadModel(absPath) {
+    configureOrt();
+    let p = sessions.get(absPath);
+    if (!p) {
+        p = ort.InferenceSession.create(absPath, { logSeverityLevel: 3 });
+        sessions.set(absPath, p);
+    }
+    return p;
+}
+export function resolveModelPath(filename) {
+    const override = process.env.EDITMAMEI_MODELS_DIR;
+    if (override)
+        return join(override, filename);
+    const here = dirname(fileURLToPath(import.meta.url));
+    return join(here, '..', 'models', filename);
+}
+export function decodeJpeg(path) {
+    let img;
+    try {
+        img = decode(readFileSync(path), { useTArray: true, formatAsRGBA: true });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`failed to decode JPEG at ${path}: ${msg}`);
+    }
+    return { width: img.width, height: img.height, data: img.data };
+}
+export { ort };

package/dist/license/env-activation.js

@@ -1,20 +1,59 @@
 import { Logger } from '../utils/logger.js';
 import { readLicense } from './store.js';
-import { activate } from './entitlement.js';
+import { activate, isProEntitled } from './entitlement.js';
+import { provisionModules } from '../delivery/provision.js';
+import { readInstalledModule, PRO_SKU } from '../delivery/store.js';
 const logger = new Logger('License');
-export async function maybeActivateFromEnv(env = process.env, ops = {}) {
+const PROVISION_BOOT_TIMEOUT_MS = 20_000;
+export async function maybeActivateFromEnv(env = process.env, ops = {}, delivery = {}) {
     const key = (env.EDITMAMEI_LICENSE_KEY ?? '').trim();
     if (!key)
         return;
     const cached = readLicense(ops);
-    if (cached && cached.key === key)
-        return;
+    if (!cached || cached.key !== key) {
+        try {
+            await activate(key, ops);
+            logger.info('Activated Pro from EDITMAMEI_LICENSE_KEY.');
+        }
+        catch (err) {
+            logger.warn(`Could not activate from EDITMAMEI_LICENSE_KEY (continuing as Community): ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+    }
     try {
-        await activate(key, ops);
-        logger.info('Activated Pro from EDITMAMEI_LICENSE_KEY.');
+        if (isProEntitled(ops) && !readInstalledModule(PRO_SKU, ops)) {
+            const provisioning = provisionModules(key, {
+                dir: ops.dir,
+                now: ops.now,
+                config: delivery.config,
+                fetchImpl: delivery.fetchImpl,
+                sleep: delivery.sleep,
+                signingKeys: delivery.signingKeys,
+            });
+            provisioning.catch(() => { });
+            let timer;
+            const deadline = new Promise((resolve) => {
+                timer = setTimeout(() => resolve(null), delivery.bootTimeoutMs ?? PROVISION_BOOT_TIMEOUT_MS);
+                timer.unref?.();
+            });
+            const prov = await Promise.race([provisioning, deadline]);
+            if (timer)
+                clearTimeout(timer);
+            if (!prov) {
+                logger.warn('Pro module provisioning did not finish in time — continuing as Community; the next start retries.');
+            }
+            else {
+                for (const m of prov.installed)
+                    logger.info(`Installed ${m.sku} module v${m.version}.`);
+                for (const e of prov.errors) {
+                    logger.warn(`Could not provision the ${e.sku} module (Pro stays dark): ${e.message}`);
+                }
+            }
+        }
     }
     catch (err) {
-        logger.warn(`Could not activate from EDITMAMEI_LICENSE_KEY (continuing as Community): ` +
+        logger.warn(`Pro module provisioning failed (continuing without Pro): ` +
             `${err instanceof Error ? err.message : String(err)}`);
     }
 }