memory-extract 0.1.3 → 0.1.5

package/README.md

@@ -0,0 +1,83 @@
+# memory-extract
+
+Embed files into a PNG image and open them back from the PNG alone.
+
+Use it to ship static sites, single assets or small apps as portable `.png` cartridges. The image still opens as a normal PNG and the payload lives in a custom chunk inside the file.
+
+## Install
+
+```bash
+npm install memory-extract
+```
+
+## CLI
+
+### `memory-pack [path] [filename]`
+
+Pack a file or directory into a memory PNG
+
+```bash
+memory-pack               # pack current directory → ./<folder-name>.png
+memory-pack dist          # pack ./dist → ./dist.png
+memory-pack dist App      # pack ./dist → ./App.png
+```
+
+
+| Argument   | Default            | Description                               |
+| ---------- | ------------------ | ----------------------------------------- |
+| `path`     | `.`                | File or directory to pack                 |
+| `filename` | basename of `path` | Output PNG name (`.png` added if missing) |
+
+
+
+| Flag             | Description                                  |
+| ---------------- | -------------------------------------------- |
+| `--cover <path>` | Cover image instead of the default blank PNG |
+| `--out <path>`   | Output PNG path                              |
+
+
+
+
+### `memory-unpack <png> [out-dir]`
+
+Extract the packed files from a memory PNG
+
+```bash
+memory-unpack dist.png
+memory-unpack dist.png ./restored
+```
+
+
+
+### `memory-play <png>`
+
+Open a memory PNG in the browser
+
+```bash
+memory-play App.png
+```
+
+## Library
+
+Browser exports:
+
+```js
+import {
+  extractMemory,
+  listManifestFiles,
+  readMemoryFile,
+  createMemoryBlob,
+} from "memory-extract";
+```
+
+
+
+Node helpers:
+
+```js
+import { embedMemory, encodeMemoryPayload } from "memory-extract/node";
+import { guessMimeType, encodeV2Archive } from "memory-extract/payload";
+```
+
+`createMemoryBlob()` is for in-browser launch via blob URLs. The CLI uses HTTP or `file://` instead.
+

package/package.json

@@ -2,7 +2,7 @@
   "name": "memory-extract",
   "description": "Tool for embedding data into PNG images",
   "license": "MIT",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "author": "semigarden",
   "repository": {
     "type": "git",

package/tools/play.mjs

@@ -153,7 +153,7 @@ const playMemoryPng = async (input, label = input) => {
             filePaths,
             playMode.entry
         );
-        const openUrl = new URL(playMode.entry, baseUrl).href;
+        const openUrl = baseUrl;
 
         await runServerSession({
             input,

package/tools/playMemoryServer.mjs

@@ -16,6 +16,15 @@ export const normalizeUrlPath = (pathname) => {
 export const urlPathToManifestPath = (urlPath) =>
     urlPath === "/" ? "" : urlPath.slice(1);
 
+export const resolveEntryMountPrefix = (entryPath) => {
+    const slash = entryPath.lastIndexOf("/");
+    if (slash <= 0) {
+        return "";
+    }
+
+    return entryPath.slice(0, slash + 1);
+};
+
 const hrefForEntry = (urlPath, name, isDirectory) => {
     const base = urlPath === "/" ? "" : urlPath;
     const href = `${base}/${name}${isDirectory ? "/" : ""}`.replace(/\/+/g, "/");
@@ -30,14 +39,12 @@ export const resolveManifestPathForUrl = (urlPath, manifestPaths, entryPath = ""
         return direct;
     }
 
-    const entryDir = entryPath.includes("/")
-        ? entryPath.slice(0, entryPath.lastIndexOf("/"))
-        : "";
+    const mountPrefix = resolveEntryMountPrefix(entryPath);
 
-    if (direct && entryDir) {
-        const joined = `${entryDir}/${direct}`.replace(/\/+/g, "/");
-        if (manifestSet.has(joined)) {
-            return joined;
+    if (direct && mountPrefix) {
+        const mounted = `${mountPrefix}${direct}`.replace(/\/+/g, "/");
+        if (manifestSet.has(mounted)) {
+            return mounted;
         }
     }
 
@@ -68,27 +75,51 @@ const serveManifestFile = (response, manifest, fileBytes, manifestPath) => {
     response.end(body);
 };
 
+const isHtmlEntryPath = (entryPath) =>
+    entryPath.endsWith(".html") || entryPath.endsWith(".htm");
+
 export const createMemoryPlayHandler = (manifest, fileBytes, filePaths, entryPath) => {
     const manifestPaths = filePaths ?? listManifestFiles(manifest);
+    const mountPrefix = resolveEntryMountPrefix(entryPath);
 
     return (request, response) => {
         try {
             const url = new URL(request.url ?? "/", "http://localhost");
             const urlPath = normalizeUrlPath(url.pathname);
 
+            if (mountPrefix) {
+                const mountRoot = `/${mountPrefix.replace(/\/$/, "")}`;
+
+                if (urlPath === mountRoot || urlPath.startsWith(`${mountRoot}/`)) {
+                    const relative =
+                        urlPath === mountRoot ? "/" : urlPath.slice(mountRoot.length);
+                    response.writeHead(302, {
+                        Location: relative.startsWith("/") ? relative : `/${relative}`,
+                    });
+                    response.end();
+                    return;
+                }
+            }
+
+            let manifestPath = null;
+
             if (urlPath === "/") {
-                response.writeHead(302, {
-                    Location: `/${entryPath}`,
-                });
-                response.end();
-                return;
+                manifestPath = entryPath;
+            } else {
+                manifestPath = resolveManifestPathForUrl(
+                    urlPath,
+                    manifestPaths,
+                    entryPath
+                );
             }
 
-            const manifestPath = resolveManifestPathForUrl(
-                urlPath,
-                manifestPaths,
-                entryPath
-            );
+            if (
+                !manifestPath &&
+                isHtmlEntryPath(entryPath) &&
+                request.method === "GET"
+            ) {
+                manifestPath = entryPath;
+            }
 
             if (!manifestPath) {
                 response.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });

package/tools/unpack.mjs

@@ -27,7 +27,7 @@ const parseArgs = async (argv) => {
 const main = async () => {
     const { input, explicitOut, host } = await parseArgs(process.argv.slice(2));
     const buffer = await readFile(input);
-    const { png, manifest, fileBytes, version } = extractMemory(buffer);
+    const { manifest, fileBytes, version } = extractMemory(buffer);
     const outDir = resolveUnpackDir({
         manifestSource: manifest.source ?? "",
         explicitOut,
@@ -35,7 +35,6 @@ const main = async () => {
     });
 
     await mkdir(outDir, { recursive: true });
-    await writeFile(path.join(outDir, "cover.png"), png);
 
     for (const filePath of listManifestFiles(manifest)) {
         const target = resolveSafePath(
@@ -48,11 +47,6 @@ const main = async () => {
         await writeFile(target, readMemoryFile(manifest, filePath, fileBytes));
     }
 
-    await writeFile(
-        path.join(outDir, "manifest.json"),
-        `${JSON.stringify(manifest, null, 2)}\n`
-    );
-
     console.log(
         `Extracted ${listManifestFiles(manifest).length} files to ${outDir} (format v${version})`
     );