@mpgd/cli 0.33.1 → 0.33.2

package/dist/asset-pack-verify.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
 import { lstat, open, opendir, realpath, stat } from 'node:fs/promises';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { verifyZipV1Archive, ZipDecodeError, } from '@mpgd/phaser-assets/archive-validation';
@@ -6,6 +7,7 @@ import { defaultArchiveWorkerLimits } from '@mpgd/phaser-assets/archives';
 import { validatePhaserPackDeliveryManifest, } from '@mpgd/phaser-assets/pack-format';
 const DEFAULT_MANIFEST_BYTE_CAP = 32 * 1024 * 1024;
 const DEFAULT_VERIFY_TIMEOUT_MS = 120_000;
+const FIFO_WRITER_GRACE_MS = 1000;
 /** The watchdog arms one millisecond after the deadline. Leave one
  * millisecond of headroom so the largest accepted timeout plus that offset
  * still fits the platform timer range instead of clamping to 1 ms. */
@@ -255,10 +257,10 @@ const inventoryRoot = async (root, deadline) => {
     return { files, bytes, largest, truncated };
 };
 const readManifestCapped = async (manifestPath, cap, deadline) => {
-    // Open through the deadline: a FIFO with no writer blocks inside
-    // open(2) before any stream event exists, and destroying a stream
-    // cannot cancel that pending open.
-    const handle = await deadline.race(open(resolve(manifestPath), 'r'));
+    // Open through the deadline. POSIX O_NONBLOCK keeps FIFO open/read calls
+    // bounded; Windows retains the stream fallback under the same deadline.
+    const flags = process.platform === 'win32' ? 'r' : constants.O_RDONLY | constants.O_NONBLOCK;
+    const handle = await deadline.race(open(resolve(manifestPath), flags));
     const chunks = [];
     let received = 0;
     let stalled = false;
@@ -292,30 +294,85 @@ const readManifestCapped = async (manifestPath, cap, deadline) => {
                 throw new Error(`Delivery manifest changed while reading (expected ${expectedBytes} bytes, received more)`);
             }
         }
+        else if (process.platform !== 'win32') {
+            // A blocking FIFO read can remain pending after stream.destroy() on
+            // some Linux hosts. O_NONBLOCK bounds each read: EAGAIN means a writer
+            // is connected but has no data; a later zero-byte read is its EOF.
+            const buffer = Buffer.allocUnsafe(Math.min(STREAM_CHUNK_BYTES, cap + 1));
+            const isFifo = info.isFIFO();
+            // A writer can open and close between read polls without ever yielding
+            // EAGAIN. Bound the initial connection wait so that empty EOF cannot
+            // consume the default two-minute verification budget.
+            const writerGraceUntil = performance.now() + Math.min(FIFO_WRITER_GRACE_MS, deadline.remainingMs());
+            let writerObserved = false;
+            while (true) {
+                deadline.sample();
+                let bytesRead;
+                let wouldBlock = false;
+                try {
+                    ({ bytesRead } = await deadline.race(handle.read(buffer, 0, buffer.byteLength, null)));
+                }
+                catch (error) {
+                    if (typeof error !== 'object'
+                        || error === null
+                        || !('code' in error)
+                        || (error.code !== 'EAGAIN' && error.code !== 'EWOULDBLOCK')) {
+                        throw error;
+                    }
+                    writerObserved = true;
+                    wouldBlock = true;
+                    bytesRead = 0;
+                }
+                if (bytesRead === 0) {
+                    // Other sources have ordinary EOF. An unconnected FIFO waits only
+                    // for its bounded startup grace; an observed writer has hung up.
+                    if (!wouldBlock
+                        && (!isFifo || writerObserved || performance.now() >= writerGraceUntil)) {
+                        break;
+                    }
+                    const waitMs = Math.min(10, Math.max(1, deadline.remainingMs()));
+                    await deadline.race(new Promise((resume) => setTimeout(resume, waitMs)));
+                    continue;
+                }
+                writerObserved = true;
+                received += bytesRead;
+                if (received > cap) {
+                    throw new Error(`Delivery manifest exceeds ${cap} bytes`);
+                }
+                chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
+                deadline.sample();
+            }
+        }
         else {
-            // FIFOs and other non-regular sources retain the stream watchdog: a
-            // pending read must be destroyed after the deadline so a direct
-            // FileHandle.read cannot leave the smoke process alive behind a
-            // rejected race.
+            // Windows non-regular sources retain the stream watchdog. A pending
+            // read must be destroyed at the deadline, then the race can return
+            // without waiting for that read to settle.
             const stream = handle.createReadStream({
                 highWaterMark: STREAM_CHUNK_BYTES,
                 autoClose: false,
             });
             const timer = deadline.armStream(stream);
             try {
-                for await (const chunk of stream) {
-                    const view = chunk;
-                    received += view.byteLength;
-                    if (received > cap) {
-                        stream.destroy();
-                        throw new Error(`Delivery manifest exceeds ${cap} bytes`);
+                await deadline.race((async () => {
+                    for await (const chunk of stream) {
+                        const view = chunk;
+                        received += view.byteLength;
+                        if (received > cap) {
+                            stream.destroy();
+                            throw new Error(`Delivery manifest exceeds ${cap} bytes`);
+                        }
+                        chunks.push(Buffer.from(view));
+                        deadline.sample();
                     }
-                    chunks.push(Buffer.from(view));
-                    deadline.sample();
-                }
+                })());
             }
             finally {
+                // Destroy may not wake a pending FIFO read until its writer closes.
+                // The raced deadline returns the report without waiting for that read.
                 clearTimeout(timer);
+                if (!stream.destroyed) {
+                    stream.destroy();
+                }
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/cli",
-  "version": "0.33.1",
+  "version": "0.33.2",
   "description": "Gunshi CLI for mpgd-kit starter generation and target workflow orchestration.",
   "license": "MIT",
   "repository": {
@@ -53,18 +53,18 @@
     "@types/node": "^24.0.0",
     "ttsc": "0.30.4",
     "typescript": "7.0.2",
-    "@mpgd/adapter-ait": "0.12.3",
-    "@mpgd/adapter-browser": "0.7.4",
-    "@mpgd/adapter-devvit": "0.9.9",
-    "@mpgd/adapter-capacitor": "0.4.11",
-    "@mpgd/adapter-verse8": "0.3.7",
-    "@mpgd/analytics": "0.3.13",
+    "@mpgd/adapter-capacitor": "0.4.12",
+    "@mpgd/adapter-ait": "0.12.4",
+    "@mpgd/adapter-browser": "0.7.5",
+    "@mpgd/adapter-devvit": "0.9.10",
+    "@mpgd/adapter-verse8": "0.3.8",
+    "@mpgd/analytics": "0.3.14",
     "@mpgd/bridge": "0.9.1",
-    "@mpgd/game-services": "0.15.2",
-    "@mpgd/i18n": "0.6.2",
-    "@mpgd/target-config": "0.15.1",
-    "@mpgd/platform": "0.12.1",
-    "@mpgd/catalog": "0.7.3"
+    "@mpgd/catalog": "0.7.4",
+    "@mpgd/game-services": "0.15.3",
+    "@mpgd/platform": "0.12.2",
+    "@mpgd/i18n": "0.6.3",
+    "@mpgd/target-config": "0.15.2"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/templates/phaser-game/package.json

@@ -57,6 +57,7 @@
   "dependencies": {
     "@ait-co/polyfill": "^0.1.19",
     "@apps-in-toss/web-framework": "3.5.0",
+    "@capacitor/core": "8.5.2",
     "@mpgd/adapter-ait": "__MPGD_DEPENDENCY_VERSION_ADAPTER_AIT__",
     "@mpgd/adapter-browser": "__MPGD_DEPENDENCY_VERSION_ADAPTER_BROWSER__",
     "@mpgd/adapter-capacitor": "__MPGD_DEPENDENCY_VERSION_ADAPTER_CAPACITOR__",