@ghostlytools/cli 1.3.9 → 1.3.10

package/dist/assets/{server-p5DJnN7T.js → server-C-EkLCCt.js}

@@ -10233,6 +10233,8 @@ var BUNDLES_KEPT = {
 };
 /** The first bytes of a bundle: magic, the manifest's length and the largest manifest. */
 var PEEK_BYTES = APP_BUNDLE_MAGIC.length + 4 + APP_BUNDLE_LIMITS.manifestBytes;
+/** What a peek reads first: the magic, the length and any usual manifest (about 1 KiB). A longer one is read to its end after. */
+var PEEK_FIRST_BYTES = 4096;
 var bundleId = (digest) => `app-${digest}`;
 /**
 * The key of a scope's counter row (`AppScopeCount` as JSON in `value`, `size` 0): an app's key is never empty
@@ -10398,6 +10400,13 @@ function peekAppManifest(bytes) {
 		return null;
 	}
 }
+/** Where a bundle's manifest ends, from its first bytes, or null when they are not a bundle's or name a manifest too long. */
+function peekManifestEnd(bytes) {
+	const magic = utf8Encode(APP_BUNDLE_MAGIC);
+	if (bytes.length < magic.length + 4 || !magic.every((b, i) => bytes[i] === b)) return null;
+	const end = magic.length + 4 + new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(magic.length);
+	return end <= PEEK_BYTES ? end : null;
+}
 var Apps = class {
 	host;
 	staged = /* @__PURE__ */ new Map();
@@ -10856,6 +10865,23 @@ var Apps = class {
 		return read;
 	}
 	/**
+	* The manifest at the start of the bundle at `url`, unchecked (`peekAppManifest`): its first `PEEK_FIRST_BYTES`, and
+	* only for a longer manifest a second read from the start to exactly its end (from the start: one file's bytes, even
+	* when it changed between the two).
+	*/
+	async peekAt(url) {
+		const first = await this.host.fetch(url, {
+			maxBytes: PEEK_FIRST_BYTES,
+			peek: true
+		});
+		const end = peekManifestEnd(first);
+		if (end === null || end <= first.length || first.length < PEEK_FIRST_BYTES) return peekAppManifest(first);
+		return peekAppManifest(await this.host.fetch(url, {
+			maxBytes: end,
+			peek: true
+		}));
+	}
+	/**
 	* Reads the index at `url`. With the index held for this store, bytes equal to it (by digest) are the held index: its
 	* signature and every revocation in it were checked when it was read, so only its expiry is taken again. Any other
 	* index is read with a pause every few ms (the engine shares the page's thread, and an index holds up to 4096
@@ -11415,10 +11441,7 @@ var Apps = class {
 			if (pinned === void 0) for (const url of (app.manifest.sources ?? []).filter(isAppFetchUrl)) {
 				if (candidates.has(url)) continue;
 				try {
-					const peek = peekAppManifest(await this.host.fetch(url, {
-						maxBytes: PEEK_BYTES,
-						peek: true
-					}));
+					const peek = await this.peekAt(url);
 					if (peek && newer(peek)) candidates.set(url, { holds: peek });
 				} catch {}
 			}
@@ -11430,10 +11453,7 @@ var Apps = class {
 				if (want.peek) {
 					let peek;
 					try {
-						peek = peekAppManifest(await this.host.fetch(url, {
-							maxBytes: PEEK_BYTES,
-							peek: true
-						}));
+						peek = await this.peekAt(url);
 					} catch {
 						continue;
 					}
@@ -11589,10 +11609,7 @@ var Apps = class {
 		if (app.store === void 0) urls.push(...app.manifest.sources ?? []);
 		for (const url of new Set(urls.filter(isAppFetchUrl))) {
 			try {
-				if (peekAppManifest(await this.host.fetch(url, {
-					maxBytes: PEEK_BYTES,
-					peek: true
-				}))?.digest !== app.digest) continue;
+				if ((await this.peekAt(url))?.digest !== app.digest) continue;
 			} catch {
 				continue;
 			}
@@ -43925,4 +43942,4 @@ function signalKind(signal) {
 //#endregion
 export { EngineServer };
 
-//# sourceMappingURL=server-p5DJnN7T.js.map
+//# sourceMappingURL=server-C-EkLCCt.js.map