editmamei 0.20.0 → 0.22.1

package/dist/core/tool-tiers.js

@@ -1,86 +1,95 @@
 export const TOOL_TIERS = {
-    photoshop_ping: 'community',
-    photoshop_list_capabilities: 'community',
-    photoshop_report_problem: 'community',
-    photoshop_list_actions: 'pro',
-    photoshop_play_action: 'pro',
-    photoshop_execute_script: 'pro',
-    photoshop_add_adjustment_layer: 'community',
-    photoshop_apply_adjustment: 'community',
-    photoshop_create_document: 'community',
-    photoshop_close_document: 'community',
-    photoshop_open_document: 'community',
-    photoshop_save_psd: 'community',
-    photoshop_export: 'community',
-    photoshop_apply_filter: 'community',
-    photoshop_create_group: 'community',
-    photoshop_move_layer_to_group: 'community',
-    photoshop_set_group_blend_mode: 'community',
-    photoshop_ungroup: 'community',
-    photoshop_delete_group: 'community',
-    photoshop_create_clipping_mask: 'community',
-    photoshop_release_clipping_mask: 'dev',
-    photoshop_undo: 'community',
-    photoshop_redo: 'community',
-    photoshop_place_image: 'community',
-    photoshop_resize_image: 'community',
-    photoshop_crop_document: 'community',
-    photoshop_convert_image_mode: 'community',
-    photoshop_move_layer_to_position: 'community',
-    photoshop_convert_to_smart_object: 'community',
-    photoshop_rasterize_layer: 'community',
-    photoshop_set_layer: 'community',
-    photoshop_duplicate_layer: 'community',
-    photoshop_layer_via_copy: 'community',
-    photoshop_merge: 'community',
-    photoshop_bake_layer: 'community',
-    photoshop_add_layer_style: 'community',
-    photoshop_create_layer: 'community',
-    photoshop_delete_layer: 'community',
-    photoshop_create_text_layer: 'community',
-    photoshop_fill_layer: 'community',
-    photoshop_add_fill_layer: 'community',
-    photoshop_select_layer: 'community',
-    photoshop_transform_layer: 'community',
-    photoshop_warp_layer: 'pro',
-    photoshop_warp_layer_mesh: 'pro',
-    photoshop_transform_canvas: 'community',
-    photoshop_guides: 'community',
-    photoshop_inspect: 'community',
-    photoshop_overview: 'community',
-    photoshop_get_preview: 'community',
-    photoshop_get_layer_bounds_diff: 'community',
-    photoshop_compare_regions: 'community',
-    photoshop_get_histogram: 'community',
-    photoshop_retouch: 'community',
-    photoshop_apply_brush_stroke: 'dev',
-    photoshop_detect: 'community',
-    photoshop_object: 'dev',
-    photoshop_portrait_touchup: 'dev',
-    photoshop_text_on_object: 'dev',
-    photoshop_detect_landmarks: 'pro',
-    photoshop_select_face_feature: 'pro',
-    photoshop_stroke_face_contour: 'dev',
-    photoshop_scene: 'community',
-    photoshop_select_by_reference: 'community',
-    photoshop_select: 'community',
-    photoshop_select_subject: 'pro',
-    photoshop_select_sky: 'pro',
-    photoshop_select_subject_instance: 'pro',
-    photoshop_modify_selection: 'community',
-    photoshop_get_selection_preview: 'community',
-    photoshop_selection_channel: 'community',
-    photoshop_layer_mask: 'community',
-    photoshop_path: 'community',
-    photoshop_vector_mask: 'community',
-    photoshop_template_create_evidence: 'pro',
-    photoshop_template_save: 'pro',
-    photoshop_template_list: 'pro',
-    photoshop_template_apply: 'pro',
-    photoshop_template_verify: 'pro',
-    photoshop_template_recall: 'pro',
-    photoshop_template_delete: 'pro',
-    photoshop_set_text: 'community',
+    ps_ping: 'community',
+    ps_list_capabilities: 'community',
+    ps_report_problem: 'community',
+    ps_list_actions: 'pro',
+    ps_play_action: 'pro',
+    ps_execute_script: 'pro',
+    ps_add_adjustment_layer: 'community',
+    ps_apply_adjustment: 'community',
+    ps_create_document: 'community',
+    ps_close_document: 'community',
+    ps_open_document: 'community',
+    ps_save_psd: 'community',
+    ps_export: 'community',
+    ps_apply_filter: 'community',
+    ps_create_group: 'community',
+    ps_move_layer_to_group: 'community',
+    ps_set_group_blend_mode: 'community',
+    ps_ungroup: 'community',
+    ps_delete_group: 'community',
+    ps_create_clipping_mask: 'community',
+    ps_release_clipping_mask: 'dev',
+    ps_undo: 'community',
+    ps_redo: 'community',
+    ps_place_image: 'community',
+    ps_resize_image: 'community',
+    ps_crop_document: 'community',
+    ps_convert_image_mode: 'community',
+    ps_move_layer_to_position: 'community',
+    ps_convert_to_smart_object: 'community',
+    ps_rasterize_layer: 'community',
+    ps_set_layer: 'community',
+    ps_duplicate_layer: 'community',
+    ps_copy_to_new_layer: 'community',
+    ps_merge: 'community',
+    ps_bake_layer: 'community',
+    ps_add_layer_style: 'community',
+    ps_create_layer: 'community',
+    ps_delete_layer: 'community',
+    ps_create_text_layer: 'community',
+    ps_fill_layer: 'community',
+    ps_add_fill_layer: 'community',
+    ps_select_layer: 'community',
+    ps_transform_layer: 'community',
+    ps_warp_layer: 'pro',
+    ps_warp_layer_mesh: 'pro',
+    ps_warp_layer_along: 'pro',
+    ps_warp_layer_region: 'pro',
+    ps_warp_layer_to: 'pro',
+    ps_apply_camera_raw: 'pro',
+    ps_transform_canvas: 'community',
+    ps_guides: 'community',
+    ps_inspect: 'community',
+    ps_overview: 'community',
+    ps_get_preview: 'community',
+    ps_get_layer_bounds_diff: 'community',
+    ps_compare_regions: 'community',
+    ps_get_histogram: 'community',
+    ps_retouch: 'community',
+    ps_apply_brush_stroke: 'dev',
+    ps_detect: 'community',
+    ps_edit_object: 'pro',
+    ps_portrait_touchup: 'dev',
+    ps_add_text_to_object: 'pro',
+    ps_detect_landmarks: 'pro',
+    ps_select_face_feature: 'pro',
+    ps_stroke_face_contour: 'dev',
+    ps_read_scene: 'community',
+    ps_select_by_reference: 'community',
+    ps_select: 'community',
+    ps_select_subject: 'community',
+    ps_select_sky: 'community',
+    ps_select_subject_instance: 'pro',
+    ps_select_object: 'pro',
+    ps_modify_selection: 'community',
+    ps_get_selection_preview: 'community',
+    ps_selection_channel: 'community',
+    ps_layer_mask: 'community',
+    ps_path: 'community',
+    ps_vector_mask: 'community',
+    ps_apply_image: 'community',
+    ps_calculations: 'community',
+    ps_shape: 'community',
+    ps_resolve_placement: 'pro',
+    ps_template_create_evidence: 'pro',
+    ps_template_save: 'pro',
+    ps_template_list: 'pro',
+    ps_template_apply: 'pro',
+    ps_template_verify: 'pro',
+    ps_template_recall: 'pro',
+    ps_template_delete: 'pro',
+    ps_set_text: 'community',
 };
 export function tierOf(toolName) {
     const tier = TOOL_TIERS[toolName];

package/dist/delivery/provision.js

@@ -51,7 +51,7 @@ export async function provisionModules(key, opts = {}) {
                 continue;
             }
             const installed = readInstalledModule(sku, opts);
-            if (installed && installed.version === latest) {
+            if (installed && installed.version === latest && !opts.force) {
                 result.skipped.push({ sku, version: latest, reason: 'up-to-date' });
                 continue;
             }
@@ -59,7 +59,7 @@ export async function provisionModules(key, opts = {}) {
                 result.skipped.push({
                     sku,
                     version: latest,
-                    reason: `rollback-blocked (installed v${installed.version} is newer than manifest latest v${latest})`,
+                    reason: `downgrade-blocked (installed v${installed.version} is newer than manifest latest v${latest})`,
                 });
                 continue;
             }

package/dist/delivery/store.js

@@ -1,5 +1,5 @@
 import { join, dirname } from 'node:path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, readdirSync, rmSync, lstatSync, } from 'node:fs';
 import { settingsDir } from '../core/settings.js';
 import { installBundle } from './bundle.js';
 import { sha256Hex } from './crypto.js';
@@ -7,6 +7,8 @@ import { verifyModuleSignature, MODULE_SIGNING_PUBLIC_KEYS } from './signing.js'
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('Modules');
 const INSTALLED_FILENAME = 'installed.json';
+const TMP_PREFIX = '.tmp-';
+const TMP_STALE_MS = 5 * 60 * 1000;
 export const PRO_SKU = 'pro';
 export const PRO_HANDLERS_ENTRY = 'pro-handlers.mjs';
 const MODULE_MANIFEST = 'manifest.json';
@@ -72,14 +74,71 @@ function writeFileAtomic(path, data) {
     renameSync(tmp, path);
 }
 export function installModule(rec, blob, opts = {}) {
-    const dir = installedModuleDir(rec.sku, rec.version, opts);
-    installBundle(blob, rec.content_key, dir);
-    writeFileSync(moduleArtifactPath(rec.sku, rec.version, opts), Buffer.from(blob), { mode: 0o600 });
+    const finalDir = installedModuleDir(rec.sku, rec.version, opts);
+    const skuDir = dirname(finalDir);
+    const tmpDir = join(skuDir, `${TMP_PREFIX}${rec.version}-${process.pid}`);
+    rmSync(tmpDir, { recursive: true, force: true });
+    try {
+        installBundle(blob, rec.content_key, tmpDir);
+        writeFileSync(join(tmpDir, MODULE_ARTIFACT), Buffer.from(blob), { mode: 0o600 });
+    }
+    catch (err) {
+        rmSync(tmpDir, { recursive: true, force: true });
+        throw err;
+    }
+    if (opts.force && existsSync(finalDir)) {
+        rmSync(finalDir, { recursive: true, force: true });
+    }
+    try {
+        renameSync(tmpDir, finalDir);
+    }
+    catch (err) {
+        rmSync(tmpDir, { recursive: true, force: true });
+        if (!existsSync(finalDir))
+            throw err;
+    }
     const now = opts.now ?? Date.now;
     const installed = { ...rec, installed_at: new Date(now()).toISOString() };
     writeFileAtomic(installedPath(rec.sku, opts), JSON.stringify(installed, null, 2) + '\n');
+    pruneOldModuleVersions(rec.sku, rec.version, opts);
     return installed;
 }
+export function pruneOldModuleVersions(sku, keepVersion, opts = {}) {
+    const skuDir = join(modulesRoot(opts), sku);
+    if (!existsSync(skuDir))
+        return;
+    let entries;
+    try {
+        entries = readdirSync(skuDir);
+    }
+    catch (err) {
+        logger.warn(`could not list module dir for '${sku}' to prune: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    const now = (opts.now ?? Date.now)();
+    for (const entry of entries) {
+        if (entry === keepVersion || entry === INSTALLED_FILENAME)
+            continue;
+        const full = join(skuDir, entry);
+        try {
+            const st = lstatSync(full);
+            if (entry.startsWith(TMP_PREFIX)) {
+                if (now - st.mtimeMs > TMP_STALE_MS) {
+                    rmSync(full, { recursive: true, force: true });
+                    logger.info(`Pruned stale staging dir '${sku}/${entry}'.`);
+                }
+                continue;
+            }
+            if (!st.isDirectory())
+                continue;
+            rmSync(full, { recursive: true, force: true });
+            logger.info(`Pruned stale module version '${sku}' v${entry}.`);
+        }
+        catch (err) {
+            logger.warn(`could not prune stale module entry '${sku}/${entry}': ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
 export function loadVerifiedModule(sku, opts = {}, pubKeys = MODULE_SIGNING_PUBLIC_KEYS) {
     const rec = readInstalledModule(sku, opts);
     if (!rec)

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

@@ -1,6 +1,7 @@
 import { decodeJpeg as realDecodeJpeg } from './runtime.js';
 import { detectLandmarks as realDetectLandmarks, } from './landmark-detector.js';
 import { OnnxDetectionClient, } from './detection-client.js';
+import { correctMeshEyes } from './mesh-eye-correction.js';
 const LANDMARK_BACKEND = 'facemesh-468';
 export class OnnxLandmarkDetectionClient {
     base;
@@ -20,11 +21,18 @@ export class OnnxLandmarkDetectionClient {
         const img = this.decodeJpeg(imagePath);
         const minScore = this.opts.minScore ?? 0.5;
         const lmOpts = { margin: this.opts.margin };
+        const correctEyes = this.opts.correctEyes ?? true;
         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 };
+                    if (correctEyes) {
+                        const c = correctMeshEyes(img, face.features.points);
+                        face.features.points = c.points;
+                        if (c.correction)
+                            face.features.eyeCorrection = c.correction;
+                    }
                 }
             }
             catch {

package/dist/detection/mesh-eye-correction.js

@@ -0,0 +1,126 @@
+import { LANDMARK_GROUPS, LANDMARK_COUNT } from './landmark-spec.js';
+const EYE_RIGID_GROUPS = ['leftEye', 'rightEye', 'leftEyebrow', 'rightEyebrow', 'nose'];
+const EYE_RIGID_INDICES = new Set();
+for (const g of EYE_RIGID_GROUPS)
+    for (const i of LANDMARK_GROUPS[g])
+        EYE_RIGID_INDICES.add(i);
+const centroid = (pts) => ({
+    x: pts.reduce((s, p) => s + p.x, 0) / pts.length,
+    y: pts.reduce((s, p) => s + p.y, 0) / pts.length,
+});
+const bbox = (pts) => ({
+    x0: Math.min(...pts.map((p) => p.x)),
+    y0: Math.min(...pts.map((p) => p.y)),
+    x1: Math.max(...pts.map((p) => p.x)),
+    y1: Math.max(...pts.map((p) => p.y)),
+});
+const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+function makeCtx(img) {
+    const { width: W, height: H, data } = img;
+    const luma = (x, y) => {
+        const i = (y * W + x) * 4;
+        return 0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2];
+    };
+    const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+    const blur = (x, y, r) => {
+        let s = 0, n = 0;
+        for (let dy = -r; dy <= r; dy++)
+            for (let dx = -r; dx <= r; dx++) {
+                s += luma(clamp(x + dx, 0, W - 1), clamp(y + dy, 0, H - 1));
+                n++;
+            }
+        return s / n;
+    };
+    return { W, H, luma, clamp, blur };
+}
+function findEyeCenter(ctx, center, ring) {
+    const { W, H, luma, clamp, blur } = ctx;
+    const rw = ring.x1 - ring.x0, rh = ring.y1 - ring.y0;
+    const x0 = clamp(Math.round(center.x - 0.55 * rw), 0, W - 1);
+    const x1 = clamp(Math.round(center.x + 0.55 * rw), 0, W - 1);
+    const y0 = clamp(Math.round(center.y - 0.5 * rh), 0, H - 1);
+    const y1 = clamp(Math.round(center.y + 2.0 * rh), 0, H - 1);
+    const ww = x1 - x0 + 1, wh = y1 - y0 + 1;
+    if (ww < 5 || wh < 5)
+        return { x: center.x, y: center.y, atEdge: false };
+    const L = new Float32Array(ww * wh);
+    for (let y = 0; y < wh; y++)
+        for (let x = 0; x < ww; x++)
+            L[y * ww + x] = luma(x0 + x, y0 + y);
+    const edges = [];
+    const gg = [];
+    let magSum = 0;
+    for (let y = 1; y < wh - 1; y++)
+        for (let x = 1; x < ww - 1; x++) {
+            const gx = (L[y * ww + x + 1] - L[y * ww + x - 1]) / 2;
+            const gy = (L[(y + 1) * ww + x] - L[(y - 1) * ww + x]) / 2;
+            const m = Math.hypot(gx, gy);
+            gg.push({ m, x, y, gx, gy });
+            magSum += m;
+        }
+    const mean = magSum / (gg.length || 1);
+    let v = 0;
+    for (const g of gg)
+        v += (g.m - mean) ** 2;
+    const std = Math.sqrt(v / (gg.length || 1));
+    const thr = mean + 0.3 * std;
+    for (const g of gg)
+        if (g.m > thr)
+            edges.push({ x: g.x, y: g.y, gx: g.gx / g.m, gy: g.gy / g.m });
+    let best = -Infinity, bx = Math.round(center.x - x0), by = Math.round(center.y - y0);
+    for (let cy = 2; cy < wh - 2; cy += 2)
+        for (let cx = 2; cx < ww - 2; cx += 2) {
+            let s = 0;
+            for (const e of edges) {
+                const dx = e.x - cx, dy = e.y - cy, l = Math.hypot(dx, dy);
+                if (l < 3)
+                    continue;
+                const dot = (dx / l) * e.gx + (dy / l) * e.gy;
+                if (dot > 0)
+                    s += dot * dot;
+            }
+            s *= 255 - blur(x0 + cx, y0 + cy, 3);
+            if (s > best) {
+                best = s;
+                bx = cx;
+                by = cy;
+            }
+        }
+    const atEdge = bx <= 3 || bx >= ww - 4 || by >= wh - 4;
+    return { x: x0 + bx, y: y0 + by, atEdge };
+}
+function similarity(m1, m2, t1, t2) {
+    const dmx = m2.x - m1.x, dmy = m2.y - m1.y, dtx = t2.x - t1.x, dty = t2.y - t1.y;
+    const s = Math.hypot(dtx, dty) / (Math.hypot(dmx, dmy) || 1);
+    const th = Math.atan2(dty, dtx) - Math.atan2(dmy, dmx);
+    const c = Math.cos(th) * s, sn = Math.sin(th) * s;
+    return (p) => ({
+        x: t1.x + c * (p.x - m1.x) - sn * (p.y - m1.y),
+        y: t1.y + sn * (p.x - m1.x) + c * (p.y - m1.y),
+    });
+}
+export function correctMeshEyes(img, points) {
+    if (!points || points.length < LANDMARK_COUNT)
+        return { points, correction: null };
+    if (!img || !img.data || img.data.length < img.width * img.height * 4) {
+        return { points, correction: null };
+    }
+    const ctx = makeCtx(img);
+    const leftEye = LANDMARK_GROUPS.leftEye.map((i) => points[i]);
+    const rightEye = LANDMARK_GROUPS.rightEye.map((i) => points[i]);
+    const eyeLm = centroid(leftEye), eyeRm = centroid(rightEye);
+    if (dist(eyeLm, eyeRm) < 4)
+        return { points, correction: null };
+    const eyeLc = findEyeCenter(ctx, eyeLm, bbox(leftEye));
+    const eyeRc = findEyeCenter(ctx, eyeRm, bbox(rightEye));
+    const T = similarity(eyeLm, eyeRm, eyeLc, eyeRc);
+    const corrected = points.map((p, i) => (EYE_RIGID_INDICES.has(i) ? { ...T(p), z: p.z } : p));
+    return {
+        points: corrected,
+        correction: {
+            drift_left: Math.round(dist(eyeLc, eyeLm)),
+            drift_right: Math.round(dist(eyeRc, eyeRm)),
+            low_confidence: eyeLc.atEdge || eyeRc.atEdge,
+        },
+    };
+}

package/dist/detection/sam-segmenter.js

@@ -0,0 +1,83 @@
+import { loadModel, resolveModelPath, ort } from './runtime.js';
+const MODEL_ENCODER = 'pro/mobile_sam_encoder.onnx';
+const MODEL_DECODER = 'pro/mobile_sam_decoder.onnx';
+const SAM_INPUT = 1024;
+export function boxToPromptCoords(box, imgW, imgH) {
+    const s = SAM_INPUT / Math.max(imgW, imgH);
+    const [x1, y1, x2, y2] = box;
+    return {
+        coords: Float32Array.from([x1 * s, y1 * s, x2 * s, y2 * s]),
+        labels: Float32Array.from([2, 3]),
+    };
+}
+export function pointsToPromptCoords(fg, bg, imgW, imgH) {
+    const s = SAM_INPUT / Math.max(imgW, imgH);
+    const pts = [...fg, ...bg, { x: 0, y: 0 }];
+    const labels = [...fg.map(() => 1), ...bg.map(() => 0), -1];
+    const coords = new Float32Array(pts.length * 2);
+    pts.forEach((p, i) => {
+        coords[i * 2] = p.x * s;
+        coords[i * 2 + 1] = p.y * s;
+    });
+    return { coords, labels: Float32Array.from(labels) };
+}
+export function toEncoderInput(img) {
+    const { width: w, height: h, data } = img;
+    const out = new Float32Array(h * w * 3);
+    for (let p = 0; p < h * w; p++) {
+        out[p * 3] = data[p * 4];
+        out[p * 3 + 1] = data[p * 4 + 1];
+        out[p * 3 + 2] = data[p * 4 + 2];
+    }
+    return out;
+}
+export function thresholdMask(maskData, n) {
+    const mask = new Uint8Array(n);
+    for (let i = 0; i < n; i++)
+        mask[i] = maskData[i] > 0 ? 1 : 0;
+    return mask;
+}
+export class OnnxSamSegmenter {
+    async encodeImage(img) {
+        const session = await loadModel(resolveModelPath(MODEL_ENCODER));
+        const input = new ort.Tensor('float32', toEncoderInput(img), [img.height, img.width, 3]);
+        const out = await session.run({ input_image: input });
+        return out.image_embeddings;
+    }
+    async runDecoder(embedding, coords, labels, imgW, imgH) {
+        const session = await loadModel(resolveModelPath(MODEL_DECODER));
+        const nPts = labels.length;
+        const out = await session.run({
+            image_embeddings: embedding,
+            point_coords: new ort.Tensor('float32', coords, [1, nPts, 2]),
+            point_labels: new ort.Tensor('float32', labels, [1, nPts]),
+            mask_input: new ort.Tensor('float32', new Float32Array(256 * 256), [1, 1, 256, 256]),
+            has_mask_input: new ort.Tensor('float32', Float32Array.from([0]), [1]),
+            orig_im_size: new ort.Tensor('float32', Float32Array.from([imgH, imgW]), [2]),
+        });
+        const masks = out.masks;
+        const [, , mh, mw] = masks.dims;
+        return {
+            mask: thresholdMask(masks.data, mh * mw),
+            width: mw,
+            height: mh,
+            iou: out.iou_predictions.data[0] ?? 0,
+        };
+    }
+    async segmentBox(embedding, box, imgW, imgH) {
+        const { coords, labels } = boxToPromptCoords(box, imgW, imgH);
+        return this.runDecoder(embedding, coords, labels, imgW, imgH);
+    }
+    async segmentPointsAt(embedding, fg, bg, imgW, imgH) {
+        const { coords, labels } = pointsToPromptCoords(fg, bg, imgW, imgH);
+        return this.runDecoder(embedding, coords, labels, imgW, imgH);
+    }
+    async segment(img, box) {
+        const embedding = await this.encodeImage(img);
+        return this.segmentBox(embedding, box, img.width, img.height);
+    }
+    async segmentPoints(img, fg, bg = []) {
+        const embedding = await this.encodeImage(img);
+        return this.segmentPointsAt(embedding, fg, bg, img.width, img.height);
+    }
+}

package/dist/index.js

@@ -4,6 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { EditmameiServer } from './core/server.js';
 import { routeCli } from './cli/router.js';
 import { maybeActivateFromEnv } from './license/env-activation.js';
+import { refreshIfStale } from './license/entitlement.js';
 import { Logger } from './utils/logger.js';
 const logger = new Logger('Main');
 function installProcessHandlers() {
@@ -37,6 +38,7 @@ async function main() {
     try {
         logger.info('Starting Editmamei...');
         await maybeActivateFromEnv();
+        await refreshIfStale();
         const server = new EditmameiServer();
         await server.start();
         let shuttingDown = false;

package/dist/kernel/host-api.js

@@ -1 +1,2 @@
 export const KERNEL_ABI = 1;
+export const HOST_MIN_ABI = 1;

package/dist/license/entitlement.js

@@ -2,7 +2,11 @@ import { resolvePolarConfig } from './config.js';
 import { computeDeviceHash } from './device-hash.js';
 import { readLicense, writeLicense, clearLicense, } from './store.js';
 import { PolarLicenseClient, PolarLicenseError } from './polar-client.js';
+import { Logger } from '../utils/logger.js';
+const logger = new Logger('License');
 export const GRACE_MS = 30 * 24 * 60 * 60 * 1000;
+export const REFRESH_AFTER_MS = 7 * 24 * 60 * 60 * 1000;
+export const EXPIRED_REFRESH_TIMEOUT_MS = 5_000;
 export function evaluateEntitlement(rec, now) {
     if (!rec)
         return { entitled: false, reason: 'no-license' };
@@ -59,6 +63,54 @@ export async function activate(key, ops = {}) {
     writeLicense(rec, ops);
     return rec;
 }
+export async function refreshIfStale(ops = {}) {
+    const env = ops.env ?? process.env;
+    if (env.VITEST !== undefined || env.NODE_ENV === 'test')
+        return;
+    const rec = readLicense(ops);
+    if (!rec)
+        return;
+    if (rec.status === 'revoked' || rec.status === 'disabled')
+        return;
+    const now = (ops.now ?? Date.now)();
+    if (rec.expires_at !== null && Date.parse(rec.expires_at) <= now)
+        return;
+    const last = Date.parse(rec.last_validated_at);
+    const age = Number.isFinite(last) ? now - last : Infinity;
+    if (age <= REFRESH_AFTER_MS)
+        return;
+    if (age <= GRACE_MS) {
+        refresh(ops).catch((err) => {
+            logger.warn(`Background license refresh failed (grace covers offline use): ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+        });
+        return;
+    }
+    const timeoutMs = ops.expiredRefreshTimeoutMs ?? EXPIRED_REFRESH_TIMEOUT_MS;
+    const attempt = refresh(ops);
+    attempt.catch(() => { });
+    let timer;
+    try {
+        const winner = await Promise.race([
+            attempt,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve('timeout'), timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+        if (winner === 'timeout') {
+            logger.warn('License re-validation timed out past the grace window — continuing as Community; the next boot retries.');
+        }
+    }
+    catch (err) {
+        logger.warn(`License re-validation failed past the grace window (continuing as Community): ` +
+            `${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 export async function refresh(ops = {}) {
     const rec = readLicense(ops);
     if (!rec)

package/dist/modules/ce/index.js

@@ -23,12 +23,12 @@ import { createBrushTools } from '../../tools/brush-tools.js';
 import { createTransformCanvasTools } from '../../tools/transform-canvas-tools.js';
 import { createGuideTools } from '../../tools/guide-tools.js';
 import { createDetectionTools } from '../../tools/detection-tools.js';
-import { createObjectTools } from '../../tools/object-tools.js';
 import { createPortraitTools } from '../../tools/portrait-tools.js';
-import { createTextOnObjectTools } from '../../tools/text-on-object-tools.js';
 import { createSceneTools } from '../../tools/scene-tools.js';
 import { createPathTools } from '../../tools/path-tools.js';
 import { createVectorMaskTools } from '../../tools/vector-mask-tools.js';
+import { createChannelComposeTools } from '../../tools/channel-compose-tools.js';
+import { createShapeTools } from '../../tools/shape-tools.js';
 const ceFactories = [
     createDocumentTools,
     createLayerTools,
@@ -52,11 +52,11 @@ const ceFactories = [
     createTransformCanvasTools,
     createGuideTools,
     createDetectionTools,
-    createObjectTools,
     createPortraitTools,
-    createTextOnObjectTools,
     createPathTools,
     createVectorMaskTools,
+    createChannelComposeTools,
+    createShapeTools,
 ];
 export const ceModule = {
     manifest: { id: 'ce', name: 'Editmamei Community Tools', abi: KERNEL_ABI },