editmamei 0.23.0 → 1.0.0

package/dist/core/server.js

@@ -13,30 +13,18 @@ import { loadSettings, applyTelemetryEnvOverrides, applyUpdateCheckEnvOverride,
 import { TelemetryClient } from '../telemetry/client.js';
 import { resolveInstallChannel } from '../install-channel.js';
 import { checkForUpdate, shouldCheckForUpdate } from '../update/check.js';
-import { join, dirname } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { GoSnippetClient, resolveProBinaryPath, coreBinaryName } from '../api/snippet-client.js';
+import { join } from 'node:path';
+import { GoSnippetClient, coreBinaryName } from '../api/snippet-client.js';
 import { isProEntitled } from '../license/entitlement.js';
 import { createPingLicenseRefresher } from '../license/ping-refresh.js';
-import { loadVerifiedModule, readInstalledModule, installedPath, PRO_SKU, } from '../delivery/store.js';
-import { provisionModules } from '../delivery/provision.js';
-import { readLicense } from '../license/store.js';
-import { existsSync } from 'node:fs';
 import { runScript } from '../utils/run-script.js';
 import { listTemplates } from '../utils/template-storage.js';
+import { toolErrorResult } from '../utils/tool-helpers.js';
 import { Kernel } from '../kernel/kernel.js';
-import { HOST_MIN_ABI } from '../kernel/host-api.js';
 import { ceModule } from '../modules/ce/index.js';
 import { hostDetectionRuntime } from '../detection/runtime.js';
-export function classifyModuleOutcome(inputs) {
-    if (inputs.proModuleLoaded && inputs.skipReason === null)
-        return 'loaded';
-    if (inputs.skipReason === 'corrupt')
-        return 'skipped_corrupt';
-    if (inputs.skipReason === 'incompatible')
-        return 'skipped_incompatible';
-    return inputs.entitled ? 'absent' : 'lapsed';
-}
+import { ModuleLifecycle, classifyModuleOutcome } from '../kernel/module-lifecycle.js';
+export { classifyModuleOutcome };
 let logScriptOnErrorWarned = false;
 function warnLogScriptOnErrorOnce(logger) {
     if (logScriptOnErrorWarned)
@@ -64,8 +52,10 @@ export class EditmameiServer {
     sessionLog;
     telemetry;
     kernel;
-    proModule = null;
-    moduleSkipReason = null;
+    moduleLifecycle;
+    get moduleSkipReason() {
+        return this.moduleLifecycle.moduleSkipReason;
+    }
     psVersion = null;
     updateInfo = null;
     snippetClient = new GoSnippetClient();
@@ -134,7 +124,7 @@ export class EditmameiServer {
         this.toolRegistry.register('ps_ping', {
             tool: {
                 name: 'ps_ping',
-                description: 'Test connection to Photoshop and report session-start discovery signals. Read-only and idempotent. Call this once at the start of a session to confirm liveness before invoking any other tool. **If the user has given you an open-ended editing task, ALSO call `ps_overview` after this** — it returns the workflow contract + capabilities map + verification primitives so you can plan well. Returns `version` (folds the deleted photoshop_get_version), `custom_action_sets` (count of Action Sets loaded in the Photoshop Actions palette — non-zero means recorded workflows exist; if action tools are available in this build they will appear in `tools/list`), `user_templates` (count of saved Editmamei templates), and `open_documents` (names of documents already open in Photoshop, so the LLM does not have to ask which doc to edit).',
+                description: 'Test connection to Photoshop and report session-start discovery signals. Read-only and idempotent. Call this once at the start of a session to confirm liveness before invoking any other tool. **If the user has given you an open-ended editing task, ALSO call `ps_overview` after this** — it returns the workflow contract + capabilities map + verification primitives so you can plan well. Returns `version` (folds the removed get-version tool), `custom_action_sets` (count of Action Sets loaded in the Photoshop Actions palette — non-zero means recorded workflows exist; if action tools are available in this build they will appear in `tools/list`), `user_templates` (count of saved Editmamei templates), and `open_documents` (names of documents already open in Photoshop, so the LLM does not have to ask which doc to edit).',
                 inputSchema: {
                     type: 'object',
                     properties: {},
@@ -150,7 +140,7 @@ export class EditmameiServer {
                         degraded: {
                             type: 'array',
                             items: { type: 'string' },
-                            description: 'List of optional discovery signals that could not be gathered (e.g. "pingState" if the in-PS state snippet failed, "templates" if ~/.editmamei/templates was unreadable). Empty when all signals were collected cleanly. Returned defaults for any degraded field cannot be trusted as ground truth.',
+                            description: 'List of optional discovery signals that could not be gathered (e.g. "pingState" if the go-core snippet builder itself failed to produce the in-PS state script — a broken/missing local install, unrelated to whether Photoshop is reachable; liveness falls back to a cheap ping probe in that case — "templates" if ~/.editmamei/templates was unreadable). Empty when all signals were collected cleanly. Returned defaults for any degraded field cannot be trusted as ground truth.',
                         },
                         update_available: {
                             type: ['object', 'null'],
@@ -204,162 +194,39 @@ export class EditmameiServer {
             },
             handler: async () => this.listCapabilities(),
         });
-        this.proModule = this.resolveProModule();
+        this.moduleLifecycle = new ModuleLifecycle({
+            toolRegistry: this.toolRegistry,
+            logger: this.logger,
+            assertToolsClassified: () => this.assertToolsClassified(),
+        });
+        const proModule = this.moduleLifecycle.resolveProModule();
         this.kernel = new Kernel({
             registry: this.toolRegistry,
             connection: this.session.getConnection(),
             snippet: this.snippetClient,
             detection: hostDetectionRuntime(),
-            resolveModuleSnippet: (manifest) => manifest.goCoreSnippets && manifest.goCoreSnippets.length > 0 && this.proModule
-                ? new GoSnippetClient({ binaryPath: join(this.proModule.binDir, coreBinaryName()) })
+            resolveModuleSnippet: (manifest) => manifest.goCoreSnippets && manifest.goCoreSnippets.length > 0 && proModule
+                ? new GoSnippetClient({ binaryPath: join(proModule.binDir, coreBinaryName()) })
                 : null,
             sessionId: this.session.getSessionId(),
             logger: this.logger,
         });
+        this.moduleLifecycle.setKernel(this.kernel);
         this.kernel.loadBuiltins([ceModule]);
         this.assertToolsClassified();
         this.logger.info(`Registered ${this.toolRegistry.count()} tools (edition: ${EDITION})`);
     }
-    resolveProModule() {
-        if (isProEntitled()) {
-            const verified = loadVerifiedModule(PRO_SKU);
-            if (verified) {
-                const abi = readInstalledModule(PRO_SKU)?.abi ?? null;
-                return {
-                    importer: () => import(pathToFileURL(verified.handlersPath).href),
-                    binDir: verified.binDir,
-                    abi,
-                };
-            }
-            if (EDITION !== 'dev' && existsSync(installedPath(PRO_SKU))) {
-                this.moduleSkipReason = 'corrupt';
-            }
-        }
-        if (EDITION === 'dev') {
-            return {
-                importer: () => import('../modules/pro/index.js'),
-                binDir: dirname(resolveProBinaryPath()),
-                abi: null,
-            };
-        }
-        return null;
-    }
     async loadModules() {
-        if (!this.proModule)
-            return;
-        if (this.proModule.abi !== null && this.proModule.abi < HOST_MIN_ABI) {
-            this.logger.warn(`Pro module (abi ${this.proModule.abi}) is older than this host requires ` +
-                `(min abi ${HOST_MIN_ABI}) — booting Community; will re-provision in the background.`);
-            this.moduleSkipReason = 'incompatible';
-            return;
-        }
-        const snapshot = this.toolRegistry.snapshot();
-        try {
-            await this.kernel.loadDownloaded(this.proModule.importer);
-            this.assertToolsClassified();
-        }
-        catch (err) {
-            const changed = this.toolRegistry.count() - snapshot.size;
-            this.toolRegistry.restore(snapshot);
-            this.logger.warn(`Pro module could not be loaded on this host — booting Community and rolling back ` +
-                `${changed} module tool change(s); will re-provision in the background: ` +
-                `${err instanceof Error ? err.message : String(err)}`);
-            this.moduleSkipReason = 'incompatible';
-        }
+        return this.moduleLifecycle.loadModules();
     }
     computeModuleStatus() {
-        if (!readLicense())
-            return null;
-        const installed = readInstalledModule(PRO_SKU);
-        return {
-            module: PRO_SKU,
-            outcome: classifyModuleOutcome({
-                proModuleLoaded: this.proModule !== null,
-                skipReason: this.moduleSkipReason,
-                entitled: isProEntitled(),
-            }),
-            module_version: installed?.version ?? null,
-            abi: installed?.abi ?? null,
-        };
+        return this.moduleLifecycle.computeModuleStatus();
     }
     async reprovisionIfModuleSkipped(delivery = {}) {
-        const reason = this.moduleSkipReason;
-        if (reason === null)
-            return;
-        const license = readLicense();
-        if (!license) {
-            this.logger.warn('A Pro module was skipped but no cached license was found — staying Community. ' +
-                'Run `editmamei activate <key>` to restore Pro.');
-            return;
-        }
-        try {
-            const prov = await provisionModules(license.key, {
-                force: reason === 'corrupt',
-                config: delivery.config,
-                fetchImpl: delivery.fetchImpl,
-                signingKeys: delivery.signingKeys,
-                sleep: delivery.sleep,
-            });
-            if (prov.installed.length > 0) {
-                for (const m of prov.installed) {
-                    this.logger.info(`Pro module updated to v${m.version}, restart to load.`);
-                }
-                return;
-            }
-            if (prov.notConfigured) {
-                this.logger.warn('Module delivery is not configured — staying Community.');
-                return;
-            }
-            for (const e of prov.errors) {
-                this.logger.warn(`Could not re-provision the ${e.sku} module (staying Community): ${e.message}`);
-            }
-            if (prov.errors.length === 0) {
-                if (reason === 'incompatible') {
-                    this.logger.warn('The published Pro module does not yet support this host version — staying ' +
-                        'Community. Update Editmamei when a compatible release ships; ' +
-                        '`editmamei report` files a diagnostic.');
-                }
-                else {
-                    this.logger.warn('Re-provision installed nothing for the corrupt Pro module — staying ' +
-                        'Community. Try `editmamei repair`; `editmamei report` if it persists.');
-                }
-            }
-        }
-        catch (err) {
-            this.logger.warn(`Background Pro-module re-provision failed (staying Community): ` +
-                `${err instanceof Error ? err.message : String(err)}`);
-        }
+        return this.moduleLifecycle.reprovisionIfModuleSkipped(delivery);
     }
     async ensureEntitledModuleFresh(delivery = {}) {
-        if (this.moduleSkipReason !== null)
-            return;
-        if (!isProEntitled())
-            return;
-        const underTest = process.env.VITEST !== undefined || process.env.NODE_ENV === 'test';
-        if (underTest && !delivery.fetchImpl)
-            return;
-        const license = readLicense();
-        if (!license)
-            return;
-        try {
-            const prov = await provisionModules(license.key, {
-                config: delivery.config,
-                fetchImpl: delivery.fetchImpl,
-                signingKeys: delivery.signingKeys,
-                sleep: delivery.sleep,
-            });
-            for (const m of prov.installed) {
-                this.logger.info(`Pro module updated to v${m.version} — restart to load.`);
-            }
-            for (const e of prov.errors) {
-                this.logger.warn(`Pro-module freshness check could not provision the ${e.sku} module ` +
-                    `(staying on the installed version): ${e.message}`);
-            }
-        }
-        catch (err) {
-            this.logger.warn(`Background Pro-module freshness check failed (staying on the installed version): ` +
-                `${err instanceof Error ? err.message : String(err)}`);
-        }
+        return this.moduleLifecycle.ensureEntitledModuleFresh(delivery);
     }
     assertToolsClassified() {
         for (const tool of this.toolRegistry.list()) {
@@ -401,13 +268,13 @@ export class EditmameiServer {
     }
     setupHandlers() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            this.logger.debug('Listing available tools');
+            this.logger.debug('Reporting the registered tool surface');
             return {
                 tools: this.toolRegistry.list(),
             };
         });
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            this.logger.debug(`Tool called: ${request.params.name}`);
+            this.logger.debug(`Received a call for ${request.params.name}`);
             const args = request.params.arguments || {};
             return this.handleToolCall(request.params.name, args);
         });
@@ -420,29 +287,12 @@ export class EditmameiServer {
         }
         catch (error) {
             this.logger.error(`Tool execution failed: ${name}`, error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
+            return toolErrorResult('Error', error);
         }
     }
     async pingPhotoshop() {
         this.refreshLicenseOnPing();
         const connection = this.session.getConnection();
-        const isConnected = await connection.ping();
-        if (!isConnected) {
-            return {
-                content: [
-                    { type: 'text', text: 'Failed to connect to Photoshop' + this.updateNote() },
-                ],
-                structuredContent: { connected: false, update_available: this.updateInfo },
-            };
-        }
         let version = 'Unknown';
         let actionSetsCount = 0;
         let openDocuments = [];
@@ -454,8 +304,37 @@ export class EditmameiServer {
         }
         catch {
         }
+        let pingStateSnippet = null;
         try {
-            const state = (await runScript(connection, await this.snippetClient.build('pingState')));
+            pingStateSnippet = await this.snippetClient.build('pingState');
+        }
+        catch (err) {
+            this.logger.warn(`pingState snippet build failed (go-core binary missing/broken?): ${err instanceof Error ? err.message : String(err)}`);
+            const alive = await connection.ping().catch(() => false);
+            if (!alive) {
+                return {
+                    content: [
+                        { type: 'text', text: 'Photoshop did not respond' + this.updateNote() },
+                    ],
+                    structuredContent: { connected: false, update_available: this.updateInfo },
+                };
+            }
+            degraded.push('pingState');
+        }
+        if (pingStateSnippet !== null) {
+            let state;
+            try {
+                state = (await runScript(connection, pingStateSnippet));
+            }
+            catch (err) {
+                this.logger.warn(`pingState snippet failed: ${err instanceof Error ? err.message : String(err)}`);
+                return {
+                    content: [
+                        { type: 'text', text: 'Photoshop did not respond' + this.updateNote() },
+                    ],
+                    structuredContent: { connected: false, update_available: this.updateInfo },
+                };
+            }
             if (state.version)
                 version = state.version;
             if (typeof state.action_sets_count === 'number')
@@ -463,10 +342,6 @@ export class EditmameiServer {
             if (Array.isArray(state.open_documents))
                 openDocuments = state.open_documents;
         }
-        catch (err) {
-            this.logger.warn(`pingState snippet failed: ${err instanceof Error ? err.message : String(err)}`);
-            degraded.push('pingState');
-        }
         let userTemplates = 0;
         try {
             const templates = await listTemplates();
@@ -522,11 +397,12 @@ export class EditmameiServer {
         this.server.onclose = () => {
             void this.telemetry.shutdown();
         };
-        this.logger.info('MCP Server connected via stdio');
+        this.logger.info('Editmamei is listening on stdio');
     }
     async stop() {
         await this.telemetry.shutdown();
         await this.session.disconnect();
-        this.logger.info('MCP Server stopped');
+        await this.sessionLog.close();
+        this.logger.info('Editmamei has shut down');
     }
 }

package/dist/core/session.js

@@ -3,10 +3,10 @@ import { PhotoshopConnection } from '../platform/connection.js';
 import { generateSessionId } from '../utils/session-log.js';
 export class Session {
     logger;
-    connection = null;
     config;
-    lastActivity;
     sessionId;
+    connection = null;
+    lastActivity;
     constructor(config = {}) {
         this.logger = new Logger('Session');
         this.config = { autoConnect: true, ...config };
@@ -23,30 +23,29 @@ export class Session {
         return this.sessionId;
     }
     async initialize() {
-        this.logger.info('Initializing session...');
+        this.logger.info('Starting session', this.sessionId);
         if (this.config.autoConnect) {
             await this.connect();
         }
     }
     async connect() {
         try {
-            this.logger.info('Connecting to Photoshop...');
-            const connected = await this.ensureConnection().ping();
-            if (connected) {
+            const reached = await this.ensureConnection().ping();
+            if (reached) {
                 this.updateActivity();
-                this.logger.info('Successfully connected to Photoshop');
+                this.logger.info('Photoshop is reachable');
                 return true;
             }
-            this.logger.warn('Failed to connect to Photoshop');
+            this.logger.warn('Photoshop did not answer');
             return false;
         }
         catch (error) {
-            this.logger.error('Connection error:', error);
+            this.logger.error('Could not reach Photoshop', error);
             return false;
         }
     }
     async disconnect() {
-        this.logger.info('Disconnecting session...');
+        this.logger.info('Ending session', this.sessionId);
     }
     getConnection() {
         return this.ensureConnection();

package/dist/core/tool-registry.js

@@ -10,10 +10,10 @@ export class ToolRegistry {
     }
     register(name, definition) {
         if (this.tools.has(name)) {
-            this.logger.warn(`Tool '${name}' already registered, overwriting`);
+            this.logger.warn(`Replacing an already-registered tool: ${name}`);
         }
         this.tools.set(name, definition);
-        this.logger.debug(`Registered tool: ${name}`);
+        this.logger.debug(`Registered ${name}`);
     }
     registerAll(definitions) {
         for (const def of definitions) {
@@ -35,9 +35,9 @@ export class ToolRegistry {
     async execute(name, args) {
         const definition = this.tools.get(name);
         if (!definition) {
-            throw new Error(`Tool not found: ${name}`);
+            throw new Error(`No tool is registered under the name '${name}'`);
         }
-        this.logger.debug(`Executing tool: ${name}`);
+        this.logger.debug(`Dispatching ${name}`);
         const started = Date.now();
         let success = true;
         let error;

package/dist/delivery/client.js

@@ -11,6 +11,7 @@ export class DeliveryError extends Error {
         this.name = 'DeliveryError';
     }
 }
+const MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
 const USER_AGENT = 'editmamei-delivery-client/1';
 const HEADER_KEY = 'x-editmamei-license-key';
 const defaultFetch = (url, init) => fetch(url, init);
@@ -23,6 +24,7 @@ export class DeliveryClient {
     retry;
     sleep;
     minIntervalMs;
+    maxArtifactBytes;
     lastRequestAt = 0;
     constructor(opts = {}) {
         this.cfg = opts.config ?? resolveDeliveryConfig();
@@ -30,6 +32,7 @@ export class DeliveryClient {
         this.retry = { ...DEFAULT_RETRY, ...opts.retry };
         this.sleep = opts.sleep ?? defaultSleep;
         this.minIntervalMs = opts.minRequestIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+        this.maxArtifactBytes = opts.maxArtifactBytes ?? MAX_ARTIFACT_BYTES;
         if (!this.cfg.baseUrl) {
             throw new DeliveryError('Delivery endpoint is not configured. Set EDITMAMEI_DELIVERY_URL ' +
                 '(e.g. http://localhost:8787 for a local wrangler dev Worker).', 0, 'not_configured');
@@ -52,9 +55,55 @@ export class DeliveryClient {
             const res = await this.get(`/v1/modules/${sku}/${version}`, key);
             if (!res.ok)
                 throw this.errorFor(res.status, await safeText(res), this.retryAfterMsOf(res));
-            return new Uint8Array(await res.arrayBuffer());
+            const declared = Number(res.headers?.get('content-length'));
+            if (Number.isFinite(declared) && declared > this.maxArtifactBytes) {
+                throw this.oversizeError(res.status, declared);
+            }
+            const body = res.body;
+            if (!body) {
+                const buf = new Uint8Array(await res.arrayBuffer());
+                if (buf.length > this.maxArtifactBytes)
+                    throw this.oversizeError(res.status, buf.length);
+                return buf;
+            }
+            return await this.readCapped(body, res.status);
         });
     }
+    async readCapped(body, status) {
+        const reader = body.getReader();
+        const chunks = [];
+        let total = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                total += value.byteLength;
+                if (total > this.maxArtifactBytes) {
+                    try {
+                        await reader.cancel('artifact exceeds byte cap');
+                    }
+                    catch {
+                    }
+                    throw this.oversizeError(status, total);
+                }
+                chunks.push(value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        const out = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            out.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return out;
+    }
+    oversizeError(status, sizeBytes) {
+        return new DeliveryError(`Artifact exceeds the ${this.maxArtifactBytes}-byte cap (${sizeBytes} bytes) — refusing to buffer further.`, status, 'oversize');
+    }
     async withRetry(fn) {
         let lastErr;
         for (let attempt = 1; attempt <= this.retry.attempts; attempt++) {

package/dist/delivery/provision.js

@@ -1,7 +1,9 @@
 import { DeliveryClient, DeliveryError } from './client.js';
 import { sha256Hex } from './crypto.js';
-import { verifyModuleSignature } from './signing.js';
+import { verifyModuleSignature, verifyModuleSignatureV2, digestsRootSha256Hex, isModuleFileDigestArray, } from './signing.js';
 import { installModule, readInstalledModule } from './store.js';
+import { Logger } from '../utils/logger.js';
+const logger = new Logger('Modules');
 const SKU_RE = /^[a-z0-9-]{2,32}$/;
 const VERSION_RE = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/;
 const MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
@@ -99,6 +101,20 @@ export async function provisionModules(key, opts = {}) {
                 });
                 continue;
             }
+            let filesForRec;
+            let sigV2ForRec;
+            if (vEntry.files !== undefined || vEntry.sig_v2 !== undefined) {
+                if (isModuleFileDigestArray(vEntry.files) &&
+                    typeof vEntry.sig_v2 === 'string' &&
+                    verifyModuleSignatureV2(sku, latest, digest, digestsRootSha256Hex(vEntry.files), vEntry.sig_v2, opts.signingKeys)) {
+                    filesForRec = vEntry.files;
+                    sigV2ForRec = vEntry.sig_v2;
+                }
+                else {
+                    logger.warn(`${sku} v${latest} manifest carried v2 fast-boot fields that failed verification — ` +
+                        `installing via v1 trust only (boot will keep doing the full regen for this module)`);
+                }
+            }
             const contentKey = await client.fetchKey(key, sku);
             installModule({
                 sku,
@@ -108,6 +124,7 @@ export async function provisionModules(key, opts = {}) {
                 alg: contentKey.alg,
                 content_key: contentKey.key,
                 sig: sig,
+                ...(filesForRec && sigV2ForRec ? { files: filesForRec, sig_v2: sigV2ForRec } : {}),
             }, blob, opts);
             result.installed.push({ sku, version: latest });
         }

package/dist/delivery/signing.js

@@ -1,4 +1,4 @@
-import { createPublicKey, verify } from 'node:crypto';
+import { createHash, createPublicKey, verify } from 'node:crypto';
 export const DEV_MODULE_SIGNING_PUBLIC_KEY = 'MCowBQYDK2VwAyEA0DfcGMets2SlBofK4iFzLddKZB6mJF/E3beKFpLRN2o=';
 const PROD_MODULE_SIGNING_PUBLIC_KEY = 'MCowBQYDK2VwAyEAweoGOWvtf+aukiAD0FpuECSbCdZMeFzF2XYzbFWwfwo=';
 export const MODULE_SIGNING_PUBLIC_KEYS = [PROD_MODULE_SIGNING_PUBLIC_KEY];
@@ -33,3 +33,40 @@ export function verifyModuleSignature(sku, version, sha256Hex, sigB64, pubKeys =
     }
     return false;
 }
+export function isModuleFileDigestArray(v) {
+    return (Array.isArray(v) &&
+        v.every((e) => typeof e === 'object' &&
+            e !== null &&
+            typeof e.path === 'string' &&
+            typeof e.sha256 === 'string'));
+}
+export function canonicalDigestListString(files) {
+    const sorted = [...files].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    return JSON.stringify(sorted.map((f) => ({ path: f.path, sha256: f.sha256 })));
+}
+export function digestsRootSha256Hex(files) {
+    return createHash('sha256').update(canonicalDigestListString(files), 'utf8').digest('hex');
+}
+export function moduleSigV2Message(sku, version, artifactSha256Hex, digestsRootHex) {
+    return Buffer.from(`editmamei-module-sig-v2\n${sku}\n${version}\n${artifactSha256Hex}\n${digestsRootHex}`, 'utf8');
+}
+export function verifyModuleSignatureV2(sku, version, artifactSha256Hex, digestsRootHex, sigB64, pubKeys = MODULE_SIGNING_PUBLIC_KEYS) {
+    if (!sigB64)
+        return false;
+    const sig = Buffer.from(sigB64, 'base64');
+    if (sig.length === 0)
+        return false;
+    const msg = moduleSigV2Message(sku, version, artifactSha256Hex, digestsRootHex);
+    for (const b64 of pubKeys) {
+        const key = importSpki(b64);
+        if (!key)
+            continue;
+        try {
+            if (verify(null, msg, key, sig))
+                return true;
+        }
+        catch {
+        }
+    }
+    return false;
+}