resourcexjs 2.1.1 → 2.3.0

package/dist/index.js

@@ -1134,9 +1134,81 @@ async function unpackTar(archive, options = {}) {
 var gzipAsync = promisify(gzip);
 var gunzipAsync = promisify(gunzip);
 
-class RXCImpl {
+class RXPImpl {
+  _files;
+  _pathsCache = null;
+  _treeCache = null;
+  constructor(files) {
+    this._files = files;
+  }
+  paths() {
+    if (this._pathsCache) {
+      return this._pathsCache;
+    }
+    this._pathsCache = Array.from(this._files.keys()).sort();
+    return this._pathsCache;
+  }
+  tree() {
+    if (this._treeCache) {
+      return this._treeCache;
+    }
+    const root = new Map;
+    for (const path of this._files.keys()) {
+      const parts = path.split("/");
+      let currentLevel = root;
+      for (let i = 0;i < parts.length; i++) {
+        const part = parts[i];
+        const isFile = i === parts.length - 1;
+        if (!currentLevel.has(part)) {
+          const treeNode2 = {
+            node: {
+              name: part,
+              type: isFile ? "file" : "directory",
+              children: isFile ? undefined : []
+            },
+            children: new Map
+          };
+          currentLevel.set(part, treeNode2);
+        }
+        const treeNode = currentLevel.get(part);
+        if (!isFile) {
+          currentLevel = treeNode.children;
+        }
+      }
+    }
+    const convertToPathNodes = (level) => {
+      return Array.from(level.values()).map((treeNode) => {
+        if (treeNode.node.type === "directory" && treeNode.children.size > 0) {
+          treeNode.node.children = convertToPathNodes(treeNode.children);
+        }
+        return treeNode.node;
+      });
+    };
+    this._treeCache = convertToPathNodes(root);
+    return this._treeCache;
+  }
+  async file(path) {
+    const content = this._files.get(path);
+    if (!content) {
+      throw new ContentError(`file not found: ${path}`);
+    }
+    return content;
+  }
+  async files() {
+    return new Map(this._files);
+  }
+  async pack() {
+    const filesRecord = {};
+    for (const [path, content] of this._files) {
+      filesRecord[path] = content;
+    }
+    return createRXA(filesRecord);
+  }
+}
+
+class RXAImpl {
   _buffer;
-  _filesCache = null;
+  _rxpCache = null;
   constructor(buffer) {
     this._buffer = buffer;
   }
@@ -1152,17 +1224,9 @@ class RXCImpl {
   async buffer() {
     return this._buffer;
   }
-  async file(path) {
-    const filesMap = await this.files();
-    const content = filesMap.get(path);
-    if (!content) {
-      throw new ContentError(`file not found: ${path}`);
-    }
-    return content;
-  }
-  async files() {
-    if (this._filesCache) {
-      return this._filesCache;
+  async extract() {
+    if (this._rxpCache) {
+      return this._rxpCache;
     }
     const tarBuffer = await gunzipAsync(this._buffer);
     const entries = await unpackTar(tarBuffer);
@@ -1172,16 +1236,16 @@ class RXCImpl {
         filesMap.set(entry.header.name, Buffer.from(entry.data));
       }
     }
-    this._filesCache = filesMap;
-    return filesMap;
+    this._rxpCache = new RXPImpl(filesMap);
+    return this._rxpCache;
   }
 }
-function isArchiveInput(input) {
-  return "archive" in input && Buffer.isBuffer(input.archive);
+function isBufferInput(input) {
+  return "buffer" in input && Buffer.isBuffer(input.buffer);
 }
-async function createRXC(input) {
-  if (isArchiveInput(input)) {
-    return new RXCImpl(input.archive);
+async function createRXA(input) {
+  if (isBufferInput(input)) {
+    return new RXAImpl(input.buffer);
   }
   const entries = Object.entries(input).map(([name, content]) => {
     const body = typeof content === "string" ? content : content instanceof Uint8Array ? content : new Uint8Array(content);
@@ -1193,7 +1257,7 @@ async function createRXC(input) {
   });
   const tarBuffer = await packTar(entries);
   const gzipBuffer = await gzipAsync(Buffer.from(tarBuffer));
-  return new RXCImpl(gzipBuffer);
+  return new RXAImpl(gzipBuffer);
 }
 // ../type/dist/index.js
 import { gzip as gzip2, gunzip as gunzip2 } from "node:zlib";
@@ -2257,9 +2321,81 @@ async function unpackTar2(archive, options = {}) {
 var gzipAsync2 = promisify2(gzip2);
 var gunzipAsync2 = promisify2(gunzip2);
 
-class RXCImpl2 {
+class RXPImpl2 {
+  _files;
+  _pathsCache = null;
+  _treeCache = null;
+  constructor(files) {
+    this._files = files;
+  }
+  paths() {
+    if (this._pathsCache) {
+      return this._pathsCache;
+    }
+    this._pathsCache = Array.from(this._files.keys()).sort();
+    return this._pathsCache;
+  }
+  tree() {
+    if (this._treeCache) {
+      return this._treeCache;
+    }
+    const root = new Map;
+    for (const path of this._files.keys()) {
+      const parts = path.split("/");
+      let currentLevel = root;
+      for (let i = 0;i < parts.length; i++) {
+        const part = parts[i];
+        const isFile = i === parts.length - 1;
+        if (!currentLevel.has(part)) {
+          const treeNode2 = {
+            node: {
+              name: part,
+              type: isFile ? "file" : "directory",
+              children: isFile ? undefined : []
+            },
+            children: new Map
+          };
+          currentLevel.set(part, treeNode2);
+        }
+        const treeNode = currentLevel.get(part);
+        if (!isFile) {
+          currentLevel = treeNode.children;
+        }
+      }
+    }
+    const convertToPathNodes = (level) => {
+      return Array.from(level.values()).map((treeNode) => {
+        if (treeNode.node.type === "directory" && treeNode.children.size > 0) {
+          treeNode.node.children = convertToPathNodes(treeNode.children);
+        }
+        return treeNode.node;
+      });
+    };
+    this._treeCache = convertToPathNodes(root);
+    return this._treeCache;
+  }
+  async file(path) {
+    const content = this._files.get(path);
+    if (!content) {
+      throw new ContentError2(`file not found: ${path}`);
+    }
+    return content;
+  }
+  async files() {
+    return new Map(this._files);
+  }
+  async pack() {
+    const filesRecord = {};
+    for (const [path, content] of this._files) {
+      filesRecord[path] = content;
+    }
+    return createRXA2(filesRecord);
+  }
+}
+
+class RXAImpl2 {
   _buffer;
-  _filesCache = null;
+  _rxpCache = null;
   constructor(buffer) {
     this._buffer = buffer;
   }
@@ -2275,17 +2411,9 @@ class RXCImpl2 {
   async buffer() {
     return this._buffer;
   }
-  async file(path) {
-    const filesMap = await this.files();
-    const content = filesMap.get(path);
-    if (!content) {
-      throw new ContentError2(`file not found: ${path}`);
-    }
-    return content;
-  }
-  async files() {
-    if (this._filesCache) {
-      return this._filesCache;
+  async extract() {
+    if (this._rxpCache) {
+      return this._rxpCache;
     }
     const tarBuffer = await gunzipAsync2(this._buffer);
     const entries = await unpackTar2(tarBuffer);
@@ -2295,16 +2423,16 @@ class RXCImpl2 {
         filesMap.set(entry.header.name, Buffer.from(entry.data));
       }
     }
-    this._filesCache = filesMap;
-    return filesMap;
+    this._rxpCache = new RXPImpl2(filesMap);
+    return this._rxpCache;
   }
 }
-function isArchiveInput2(input) {
-  return "archive" in input && Buffer.isBuffer(input.archive);
+function isBufferInput2(input) {
+  return "buffer" in input && Buffer.isBuffer(input.buffer);
 }
-async function createRXC2(input) {
-  if (isArchiveInput2(input)) {
-    return new RXCImpl2(input.archive);
+async function createRXA2(input) {
+  if (isBufferInput2(input)) {
+    return new RXAImpl2(input.buffer);
   }
   const entries = Object.entries(input).map(([name, content]) => {
     const body = typeof content === "string" ? content : content instanceof Uint8Array ? content : new Uint8Array(content);
@@ -2316,7 +2444,7 @@ async function createRXC2(input) {
   });
   const tarBuffer = await packTar2(entries);
   const gzipBuffer = await gzipAsync2(Buffer.from(tarBuffer));
-  return new RXCImpl2(gzipBuffer);
+  return new RXAImpl2(gzipBuffer);
 }
 
 class ResourceTypeError extends ResourceXError2 {
@@ -2327,13 +2455,13 @@ class ResourceTypeError extends ResourceXError2 {
 }
 var textSerializer = {
   async serialize(rxr) {
-    return rxr.content.buffer();
+    return rxr.archive.buffer();
   },
   async deserialize(data, manifest) {
     return {
       locator: parseRXL2(manifest.toLocator()),
       manifest,
-      content: await createRXC2({ archive: data })
+      archive: await createRXA2({ buffer: data })
     };
   }
 };
@@ -2344,7 +2472,8 @@ var textResolver = {
       resource: rxr,
       schema: undefined,
       execute: async () => {
-        const buffer = await rxr.content.file("content");
+        const pkg = await rxr.archive.extract();
+        const buffer = await pkg.file("content");
         return buffer.toString("utf-8");
       }
     };
@@ -2359,13 +2488,13 @@ var textType = {
 };
 var jsonSerializer = {
   async serialize(rxr) {
-    return rxr.content.buffer();
+    return rxr.archive.buffer();
   },
   async deserialize(data, manifest) {
     return {
       locator: parseRXL2(manifest.toLocator()),
       manifest,
-      content: await createRXC2({ archive: data })
+      archive: await createRXA2({ buffer: data })
     };
   }
 };
@@ -2376,7 +2505,8 @@ var jsonResolver = {
       resource: rxr,
       schema: undefined,
       execute: async () => {
-        const buffer = await rxr.content.file("content");
+        const pkg = await rxr.archive.extract();
+        const buffer = await pkg.file("content");
         return JSON.parse(buffer.toString("utf-8"));
       }
     };
@@ -2391,13 +2521,13 @@ var jsonType = {
 };
 var binarySerializer = {
   async serialize(rxr) {
-    return rxr.content.buffer();
+    return rxr.archive.buffer();
   },
   async deserialize(data, manifest) {
     return {
       locator: parseRXL2(manifest.toLocator()),
       manifest,
-      content: await createRXC2({ archive: data })
+      archive: await createRXA2({ buffer: data })
     };
   }
 };
@@ -2408,7 +2538,8 @@ var binaryResolver = {
       resource: rxr,
       schema: undefined,
       execute: async () => {
-        return rxr.content.file("content");
+        const pkg = await rxr.archive.extract();
+        return pkg.file("content");
       }
     };
   }
@@ -2499,14 +2630,22 @@ import { createRequire } from "node:module";
 import { gzip as gzip3, gunzip as gunzip3 } from "node:zlib";
 import { promisify as promisify3 } from "node:util";
 import { homedir } from "node:os";
-import { join as join2 } from "node:path";
+import { join as join3, resolve as resolvePath } from "node:path";
+import { symlink, lstat, readlink } from "node:fs/promises";
 import { gzip as gzip22, gunzip as gunzip22 } from "node:zlib";
 import { promisify as promisify22 } from "node:util";
 import { readFile, writeFile, readdir, mkdir, rm, access, stat } from "node:fs/promises";
 import { resolve, dirname, join } from "node:path";
+import { join as join2, relative } from "node:path";
+import { stat as stat2, readFile as readFile2, readdir as readdir2 } from "node:fs/promises";
+import { gzip as gzip32, gunzip as gunzip32 } from "node:zlib";
+import { promisify as promisify32 } from "node:util";
 import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import fs from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join5 } from "node:path";
+import { gunzipSync } from "node:zlib";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -6254,7 +6393,7 @@ var require_deflate2 = __commonJS((exports) => {
     options.raw = true;
     return deflate(input, options);
   }
-  function gzip32(input, options) {
+  function gzip4(input, options) {
     options = options || {};
     options.gzip = true;
     return deflate(input, options);
@@ -6262,7 +6401,7 @@ var require_deflate2 = __commonJS((exports) => {
   exports.Deflate = Deflate;
   exports.deflate = deflate;
   exports.deflateRaw = deflateRaw;
-  exports.gzip = gzip32;
+  exports.gzip = gzip4;
 });
 var require_inffast = __commonJS((exports, module) => {
   var BAD = 30;
@@ -8277,7 +8416,7 @@ var require_ignore = __commonJS((exports, module) => {
   function makeArray(subject) {
     return Array.isArray(subject) ? subject : [subject];
   }
-  var EMPTY3 = "";
+  var EMPTY4 = "";
   var SPACE = " ";
   var ESCAPE = "\\";
   var REGEX_TEST_BLANK_LINE = /^\s+$/;
@@ -8295,7 +8434,7 @@ var require_ignore = __commonJS((exports, module) => {
   var define2 = (object, key, value) => Object.defineProperty(object, key, { value });
   var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
   var RETURN_FALSE = () => false;
-  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY3);
+  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY4);
   var cleanRangeBackSlash = (slashes) => {
     const { length } = slashes;
     return slashes.slice(0, length - length % 2);
@@ -8303,11 +8442,11 @@ var require_ignore = __commonJS((exports, module) => {
   var REPLACERS = [
     [
       /^\uFEFF/,
-      () => EMPTY3
+      () => EMPTY4
     ],
     [
       /((?:\\\\)*?)(\\?\s+)$/,
-      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY3)
+      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY4)
     ],
     [
       /(\\+?)\s/g,
@@ -9298,17 +9437,17 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
       const length = Math.ceil((62 + bpath.length + 1) / 8) * 8;
       const written = Buffer.alloc(length);
       const writer = new BufferCursor(written);
-      const stat2 = normalizeStats(entry);
-      writer.writeUInt32BE(stat2.ctimeSeconds);
-      writer.writeUInt32BE(stat2.ctimeNanoseconds);
-      writer.writeUInt32BE(stat2.mtimeSeconds);
-      writer.writeUInt32BE(stat2.mtimeNanoseconds);
-      writer.writeUInt32BE(stat2.dev);
-      writer.writeUInt32BE(stat2.ino);
-      writer.writeUInt32BE(stat2.mode);
-      writer.writeUInt32BE(stat2.uid);
-      writer.writeUInt32BE(stat2.gid);
-      writer.writeUInt32BE(stat2.size);
+      const stat3 = normalizeStats(entry);
+      writer.writeUInt32BE(stat3.ctimeSeconds);
+      writer.writeUInt32BE(stat3.ctimeNanoseconds);
+      writer.writeUInt32BE(stat3.mtimeSeconds);
+      writer.writeUInt32BE(stat3.mtimeNanoseconds);
+      writer.writeUInt32BE(stat3.dev);
+      writer.writeUInt32BE(stat3.ino);
+      writer.writeUInt32BE(stat3.mode);
+      writer.writeUInt32BE(stat3.uid);
+      writer.writeUInt32BE(stat3.gid);
+      writer.writeUInt32BE(stat3.size);
       writer.write(entry.oid, 20, "hex");
       writer.writeUInt16BE(renderCacheEntryFlags(entry));
       writer.write(entry.path, bpath.length, "utf8");
@@ -9353,13 +9492,13 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
     };
   }
   async function updateCachedIndexFile(fs2, filepath, cache) {
-    const [stat2, rawIndexFile] = await Promise.all([
+    const [stat3, rawIndexFile] = await Promise.all([
       fs2.lstat(filepath),
       fs2.read(filepath)
     ]);
     const index2 = await GitIndex.from(rawIndexFile);
     cache.map.set(filepath, index2);
-    cache.stats.set(filepath, stat2);
+    cache.stats.set(filepath, stat3);
   }
   async function isIndexStale(fs2, filepath, cache) {
     const savedStats = cache.stats.get(filepath);
@@ -9826,7 +9965,7 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
       path += "/";
     return isAbsolute ? `/${path}` : path;
   }
-  function join32(...args) {
+  function join42(...args) {
     if (args.length === 0)
       return ".";
     let joined;
@@ -10181,7 +10320,7 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
         }
       }
       for (const [key, value] of actualRefsToWrite) {
-        await acquireLock(key, async () => fs2.write(join32(gitdir, key), `${value.trim()}
+        await acquireLock(key, async () => fs2.write(join42(gitdir, key), `${value.trim()}
 `, "utf8"));
       }
       return { pruned };
@@ -10190,18 +10329,18 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
       if (!value.match(/[0-9a-f]{40}/)) {
         throw new InvalidOidError(value);
       }
-      await acquireLock(ref, async () => fs2.write(join32(gitdir, ref), `${value.trim()}
+      await acquireLock(ref, async () => fs2.write(join42(gitdir, ref), `${value.trim()}
 `, "utf8"));
     }
     static async writeSymbolicRef({ fs: fs2, gitdir, ref, value }) {
-      await acquireLock(ref, async () => fs2.write(join32(gitdir, ref), "ref: " + `${value.trim()}
+      await acquireLock(ref, async () => fs2.write(join42(gitdir, ref), "ref: " + `${value.trim()}
 `, "utf8"));
     }
     static async deleteRef({ fs: fs2, gitdir, ref }) {
       return GitRefManager.deleteRefs({ fs: fs2, gitdir, refs: [ref] });
     }
     static async deleteRefs({ fs: fs2, gitdir, refs }) {
-      await Promise.all(refs.map((ref) => fs2.rm(join32(gitdir, ref))));
+      await Promise.all(refs.map((ref) => fs2.rm(join42(gitdir, ref))));
       let text = await acquireLock("packed-refs", async () => fs2.read(`${gitdir}/packed-refs`, { encoding: "utf8" }));
       const packed = GitPackedRefs.from(text);
       const beforeSize = packed.refs.size;
@@ -11121,7 +11260,7 @@ Please file a bug report at https://github.com/isomorphic-git/isomorphic-git/iss
     format = "content",
     getExternalRefDelta
   }) {
-    let list = await fs2.readdir(join32(gitdir, "objects/pack"));
+    let list = await fs2.readdir(join42(gitdir, "objects/pack"));
     list = list.filter((x) => x.endsWith(".idx"));
     for (const filename of list) {
       const indexFile = `${gitdir}/objects/pack/${filename}`;
@@ -11862,9 +12001,9 @@ gpgsig`));
       }
       const tree = GitTree.from(object);
       for (const entry2 of tree) {
-        map.set(join32(filepath, entry2.path), entry2);
+        map.set(join42(filepath, entry2.path), entry2);
       }
-      return tree.entries().map((entry2) => join32(filepath, entry2.path));
+      return tree.entries().map((entry2) => join42(filepath, entry2.path));
     }
     async type(entry) {
       if (entry._type === false) {
@@ -11955,10 +12094,10 @@ gpgsig`));
     async readdir(entry) {
       const filepath = entry._fullpath;
       const { fs: fs2, dir } = this;
-      const names = await fs2.readdir(join32(dir, filepath));
+      const names = await fs2.readdir(join42(dir, filepath));
       if (names === null)
         return null;
-      return names.map((name) => join32(filepath, name));
+      return names.map((name) => join42(filepath, name));
     }
     async type(entry) {
       if (entry._type === false) {
@@ -11975,21 +12114,21 @@ gpgsig`));
     async stat(entry) {
       if (entry._stat === false) {
         const { fs: fs2, dir } = this;
-        let stat2 = await fs2.lstat(`${dir}/${entry._fullpath}`);
-        if (!stat2) {
+        let stat3 = await fs2.lstat(`${dir}/${entry._fullpath}`);
+        if (!stat3) {
           throw new Error(`ENOENT: no such file or directory, lstat '${entry._fullpath}'`);
         }
-        let type = stat2.isDirectory() ? "tree" : "blob";
-        if (type === "blob" && !stat2.isFile() && !stat2.isSymbolicLink()) {
+        let type = stat3.isDirectory() ? "tree" : "blob";
+        if (type === "blob" && !stat3.isFile() && !stat3.isSymbolicLink()) {
           type = "special";
         }
         entry._type = type;
-        stat2 = normalizeStats(stat2);
-        entry._mode = stat2.mode;
-        if (stat2.size === -1 && entry._actualSize) {
-          stat2.size = entry._actualSize;
+        stat3 = normalizeStats(stat3);
+        entry._mode = stat3.mode;
+        if (stat3.size === -1 && entry._actualSize) {
+          stat3.size = entry._actualSize;
         }
-        entry._stat = stat2;
+        entry._stat = stat3;
       }
       return entry._stat;
     }
@@ -12171,11 +12310,11 @@ gpgsig`));
       await fs2.rm(filepath);
     } else if (entries.length) {
       await Promise.all(entries.map((entry) => {
-        const subpath = join32(filepath, entry);
-        return fs2.lstat(subpath).then((stat2) => {
-          if (!stat2)
+        const subpath = join42(filepath, entry);
+        return fs2.lstat(subpath).then((stat3) => {
+          if (!stat3)
             return;
-          return stat2.isDirectory() ? rmRecursive(fs2, subpath) : fs2.rm(subpath);
+          return stat3.isDirectory() ? rmRecursive(fs2, subpath) : fs2.rm(subpath);
         });
       })).then(() => fs2.rmdir(filepath));
     } else {
@@ -12393,7 +12532,7 @@ gpgsig`));
       return dotgit;
     } else if (dotgitStat.isFile()) {
       return fsp._readFile(dotgit, "utf8").then((contents) => contents.trimRight().substr(8)).then((submoduleGitdir) => {
-        const gitdir = join32(dirname2(dotgit), submoduleGitdir);
+        const gitdir = join42(dirname2(dotgit), submoduleGitdir);
         return gitdir;
       });
     } else {
@@ -12418,7 +12557,7 @@ gpgsig`));
   async function abortMerge({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     commit: commit2 = "HEAD",
     cache = {}
   }) {
@@ -12487,19 +12626,19 @@ gpgsig`));
   }
 
   class GitIgnoreManager {
-    static async isIgnored({ fs: fs2, dir, gitdir = join32(dir, ".git"), filepath }) {
+    static async isIgnored({ fs: fs2, dir, gitdir = join42(dir, ".git"), filepath }) {
       if (basename(filepath) === ".git")
         return true;
       if (filepath === ".")
         return false;
       let excludes = "";
-      const excludesFile = join32(gitdir, "info", "exclude");
+      const excludesFile = join42(gitdir, "info", "exclude");
       if (await fs2.exists(excludesFile)) {
         excludes = await fs2.read(excludesFile, "utf8");
       }
       const pairs = [
         {
-          gitignore: join32(dir, ".gitignore"),
+          gitignore: join42(dir, ".gitignore"),
           filepath
         }
       ];
@@ -12508,7 +12647,7 @@ gpgsig`));
         const folder = pieces.slice(0, i).join("/");
         const file = pieces.slice(i).join("/");
         pairs.push({
-          gitignore: join32(dir, folder, ".gitignore"),
+          gitignore: join42(dir, folder, ".gitignore"),
           filepath: file
         });
       }
@@ -12597,7 +12736,7 @@ gpgsig`));
   async function add({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     cache = {},
     force = false,
@@ -12651,17 +12790,17 @@ gpgsig`));
         if (ignored)
           return;
       }
-      const stats = await fs2.lstat(join32(dir, currentFilepath));
+      const stats = await fs2.lstat(join42(dir, currentFilepath));
       if (!stats)
         throw new NotFoundError(currentFilepath);
       if (stats.isDirectory()) {
-        const children = await fs2.readdir(join32(dir, currentFilepath));
+        const children = await fs2.readdir(join42(dir, currentFilepath));
         if (parallel) {
           const promises2 = children.map((child) => addToIndex({
             dir,
             gitdir,
             fs: fs2,
-            filepath: [join32(currentFilepath, child)],
+            filepath: [join42(currentFilepath, child)],
             index: index2,
             force,
             parallel,
@@ -12674,7 +12813,7 @@ gpgsig`));
               dir,
               gitdir,
               fs: fs2,
-              filepath: [join32(currentFilepath, child)],
+              filepath: [join42(currentFilepath, child)],
               index: index2,
               force,
               parallel,
@@ -12683,7 +12822,7 @@ gpgsig`));
           }
         }
       } else {
-        const object = stats.isSymbolicLink() ? await fs2.readlink(join32(dir, currentFilepath)).then(posixifyPathBuffer) : await fs2.read(join32(dir, currentFilepath), { autocrlf });
+        const object = stats.isSymbolicLink() ? await fs2.readlink(join42(dir, currentFilepath)).then(posixifyPathBuffer) : await fs2.read(join42(dir, currentFilepath), { autocrlf });
         if (object === null)
           throw new NotFoundError(currentFilepath);
         const oid = await _writeObject({ fs: fs2, gitdir, type: "blob", object });
@@ -13079,7 +13218,7 @@ gpgsig`));
     fs: _fs,
     onSign,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref = "refs/notes/commits",
     oid,
     note,
@@ -13154,7 +13293,7 @@ gpgsig`));
   async function addRemote({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     remote,
     url,
     force = false
@@ -13224,7 +13363,7 @@ gpgsig`));
     fs: _fs,
     onSign,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     tagger: _tagger,
     message = ref,
@@ -13305,7 +13444,7 @@ gpgsig`));
   async function branch({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     object,
     checkout: checkout2 = false,
@@ -13876,7 +14015,7 @@ gpgsig`));
     onProgress,
     onPostCheckout,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     remote = "origin",
     ref: _ref,
     filepaths,
@@ -14289,7 +14428,7 @@ gpgsig`));
     static async read({ fs: fs2, gitdir }) {
       if (lock$2 === null)
         lock$2 = new AsyncLock;
-      const filepath = join32(gitdir, "shallow");
+      const filepath = join42(gitdir, "shallow");
       const oids = new Set;
       await lock$2.acquire(filepath, async function() {
         const text = await fs2.read(filepath, { encoding: "utf8" });
@@ -14305,7 +14444,7 @@ gpgsig`));
     static async write({ fs: fs2, gitdir, oids }) {
       if (lock$2 === null)
         lock$2 = new AsyncLock;
-      const filepath = join32(gitdir, "shallow");
+      const filepath = join42(gitdir, "shallow");
       if (oids.size > 0) {
         const text = [...oids].join(`
 `) + `
@@ -14333,7 +14472,7 @@ gpgsig`));
     oid,
     getExternalRefDelta
   }) {
-    let list = await fs2.readdir(join32(gitdir, "objects/pack"));
+    let list = await fs2.readdir(join42(gitdir, "objects/pack"));
     list = list.filter((x) => x.endsWith(".idx"));
     for (const filename of list) {
       const indexFile = `${gitdir}/objects/pack/${filename}`;
@@ -14622,7 +14761,7 @@ gpgsig`));
     depth = null,
     since = null,
     exclude = [],
-    relative = false,
+    relative: relative2 = false,
     tags = false,
     singleBranch = false,
     headers = {},
@@ -14670,7 +14809,7 @@ gpgsig`));
     if (exclude.length > 0 && !remoteHTTP.capabilities.has("deepen-not")) {
       throw new RemoteCapabilityError("deepen-not", "exclude");
     }
-    if (relative === true && !remoteHTTP.capabilities.has("deepen-relative")) {
+    if (relative2 === true && !remoteHTTP.capabilities.has("deepen-relative")) {
       throw new RemoteCapabilityError("deepen-relative", "relative");
     }
     const { oid, fullref } = GitRefManager.resolveAgainstMap({
@@ -14690,7 +14829,7 @@ gpgsig`));
       "ofs-delta",
       `agent=${pkg.agent}`
     ]);
-    if (relative)
+    if (relative2)
       capabilities.push("deepen-relative");
     const wants = singleBranch ? [oid] : remoteRefs.values();
     const haveRefs = singleBranch ? [ref] : await GitRefManager.listRefs({
@@ -14849,7 +14988,7 @@ gpgsig`));
     }
     if (packfileSha !== "" && !emptyPackfile(packfile)) {
       res.packfile = `objects/pack/pack-${packfileSha}.pack`;
-      const fullpath = join32(gitdir, res.packfile);
+      const fullpath = join42(gitdir, res.packfile);
       await fs2.write(fullpath, packfile);
       const getExternalRefDelta = (oid2) => _readObject({ fs: fs2, cache, gitdir, oid: oid2 });
       const idx = await GitPackIndex.fromPack({
@@ -14865,7 +15004,7 @@ gpgsig`));
     fs: fs2,
     bare = false,
     dir,
-    gitdir = bare ? dir : join32(dir, ".git"),
+    gitdir = bare ? dir : join42(dir, ".git"),
     defaultBranch = "master"
   }) {
     if (await fs2.exists(gitdir + "/config"))
@@ -14912,7 +15051,7 @@ gpgsig`));
     depth,
     since,
     exclude,
-    relative,
+    relative: relative2,
     singleBranch,
     noCheckout,
     noTags,
@@ -14944,7 +15083,7 @@ gpgsig`));
         depth,
         since,
         exclude,
-        relative,
+        relative: relative2,
         singleBranch,
         headers,
         tags: !noTags
@@ -14983,7 +15122,7 @@ gpgsig`));
     onAuthFailure,
     onPostCheckout,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     url,
     corsProxy = undefined,
     ref = undefined,
@@ -14991,7 +15130,7 @@ gpgsig`));
     depth = undefined,
     since = undefined,
     exclude = [],
-    relative = false,
+    relative: relative2 = false,
     singleBranch = false,
     noCheckout = false,
     noTags = false,
@@ -15029,7 +15168,7 @@ gpgsig`));
         depth,
         since,
         exclude,
-        relative,
+        relative: relative2,
         singleBranch,
         noCheckout,
         noTags,
@@ -15046,7 +15185,7 @@ gpgsig`));
     fs: _fs,
     onSign,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     message,
     author,
     committer,
@@ -15093,7 +15232,7 @@ gpgsig`));
   async function currentBranch({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     fullname = false,
     test = false
   }) {
@@ -15134,7 +15273,7 @@ gpgsig`));
   async function deleteBranch({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref
   }) {
     try {
@@ -15152,7 +15291,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function deleteRef({ fs: fs2, dir, gitdir = join32(dir, ".git"), ref }) {
+  async function deleteRef({ fs: fs2, dir, gitdir = join42(dir, ".git"), ref }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("ref", ref);
@@ -15172,7 +15311,7 @@ gpgsig`));
   async function deleteRemote({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     remote
   }) {
     try {
@@ -15194,7 +15333,7 @@ gpgsig`));
     ref = ref.startsWith("refs/tags/") ? ref : `refs/tags/${ref}`;
     await GitRefManager.deleteRef({ fs: fs2, gitdir, ref });
   }
-  async function deleteTag({ fs: fs2, dir, gitdir = join32(dir, ".git"), ref }) {
+  async function deleteTag({ fs: fs2, dir, gitdir = join42(dir, ".git"), ref }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("ref", ref);
@@ -15223,7 +15362,7 @@ gpgsig`));
     getExternalRefDelta
   }) {
     const results = [];
-    let list = await fs2.readdir(join32(gitdir, "objects/pack"));
+    let list = await fs2.readdir(join42(gitdir, "objects/pack"));
     list = list.filter((x) => x.endsWith(".idx"));
     for (const filename of list) {
       const indexFile = `${gitdir}/objects/pack/${filename}`;
@@ -15268,7 +15407,7 @@ gpgsig`));
   async function expandOid({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     cache = {}
   }) {
@@ -15289,7 +15428,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function expandRef({ fs: fs2, dir, gitdir = join32(dir, ".git"), ref }) {
+  async function expandRef({ fs: fs2, dir, gitdir = join42(dir, ".git"), ref }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -15376,7 +15515,7 @@ gpgsig`));
     fs: fs2,
     cache,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     index: index2,
     ourOid,
     baseOid,
@@ -15846,7 +15985,7 @@ gpgsig`));
     onAuthSuccess,
     onAuthFailure,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     url,
     remote,
@@ -15904,7 +16043,7 @@ gpgsig`));
     onAuthSuccess,
     onAuthFailure,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     remote,
     remoteRef,
@@ -15913,7 +16052,7 @@ gpgsig`));
     depth = null,
     since = null,
     exclude = [],
-    relative = false,
+    relative: relative2 = false,
     tags = false,
     singleBranch = false,
     headers = {},
@@ -15945,7 +16084,7 @@ gpgsig`));
         depth,
         since,
         exclude,
-        relative,
+        relative: relative2,
         tags,
         singleBranch,
         headers,
@@ -15960,7 +16099,7 @@ gpgsig`));
   async function findMergeBase({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oids,
     cache = {}
   }) {
@@ -15982,7 +16121,7 @@ gpgsig`));
     }
   }
   async function _findRoot({ fs: fs2, filepath }) {
-    if (await fs2.exists(join32(filepath, ".git"))) {
+    if (await fs2.exists(join42(filepath, ".git"))) {
       return filepath;
     } else {
       const parent = dirname2(filepath);
@@ -16002,7 +16141,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function getConfig({ fs: fs2, dir, gitdir = join32(dir, ".git"), path }) {
+  async function getConfig({ fs: fs2, dir, gitdir = join42(dir, ".git"), path }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -16026,7 +16165,7 @@ gpgsig`));
   async function getConfigAll({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     path
   }) {
     try {
@@ -16220,7 +16359,7 @@ gpgsig`));
     filepath
   }) {
     try {
-      filepath = join32(dir, filepath);
+      filepath = join42(dir, filepath);
       const pack = await fs2.read(filepath);
       const getExternalRefDelta = (oid) => _readObject({ fs: fs2, cache, gitdir, oid });
       const idx = await GitPackIndex.fromPack({
@@ -16241,7 +16380,7 @@ gpgsig`));
     fs: fs2,
     onProgress,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     cache = {}
   }) {
@@ -16269,7 +16408,7 @@ gpgsig`));
     fs: fs2,
     bare = false,
     dir,
-    gitdir = bare ? dir : join32(dir, ".git"),
+    gitdir = bare ? dir : join42(dir, ".git"),
     defaultBranch = "master"
   }) {
     try {
@@ -16345,7 +16484,7 @@ gpgsig`));
   async function isDescendent({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     ancestor,
     depth = -1,
@@ -16374,7 +16513,7 @@ gpgsig`));
   async function isIgnored({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath
   }) {
     try {
@@ -16398,7 +16537,7 @@ gpgsig`));
   async function listBranches({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     remote
   }) {
     try {
@@ -16452,17 +16591,17 @@ gpgsig`));
           gitdir,
           oid: entry.oid,
           filenames,
-          prefix: join32(prefix, entry.path)
+          prefix: join42(prefix, entry.path)
         });
       } else {
-        filenames.push(join32(prefix, entry.path));
+        filenames.push(join42(prefix, entry.path));
       }
     }
   }
   async function listFiles({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     cache = {}
   }) {
@@ -16506,7 +16645,7 @@ gpgsig`));
   async function listNotes({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref = "refs/notes/commits",
     cache = {}
   }) {
@@ -16530,7 +16669,7 @@ gpgsig`));
   async function listRefs({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath
   }) {
     try {
@@ -16553,7 +16692,7 @@ gpgsig`));
     }));
     return remotes;
   }
-  async function listRemotes({ fs: fs2, dir, gitdir = join32(dir, ".git") }) {
+  async function listRemotes({ fs: fs2, dir, gitdir = join42(dir, ".git") }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -16658,7 +16797,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function listTags({ fs: fs2, dir, gitdir = join32(dir, ".git") }) {
+  async function listTags({ fs: fs2, dir, gitdir = join42(dir, ".git") }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -16714,7 +16853,7 @@ gpgsig`));
     const walks = tree.entries().map(function(entry) {
       let result;
       if (entry.oid === fileId) {
-        result = join32(parentPath, entry.path);
+        result = join42(parentPath, entry.path);
         filepaths.push(result);
       } else if (entry.type === "tree") {
         result = _readObject({
@@ -16731,7 +16870,7 @@ gpgsig`));
             fileId,
             oid,
             filepaths,
-            parentPath: join32(parentPath, entry.path)
+            parentPath: join42(parentPath, entry.path)
           });
         });
       }
@@ -16866,7 +17005,7 @@ gpgsig`));
   async function log({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     ref = "HEAD",
     depth,
@@ -16901,7 +17040,7 @@ gpgsig`));
     fs: _fs,
     onSign,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ours,
     theirs,
     fastForward: fastForward2 = true,
@@ -16978,7 +17117,7 @@ gpgsig`));
     fs: fs2,
     cache,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oids
   }) {
     const hash = new Hash;
@@ -17021,7 +17160,7 @@ gpgsig`));
     const packfileSha = packfile.slice(-20).toString("hex");
     const filename = `pack-${packfileSha}.pack`;
     if (write) {
-      await fs2.write(join32(gitdir, `objects/pack/${filename}`), packfile);
+      await fs2.write(join42(gitdir, `objects/pack/${filename}`), packfile);
       return { filename };
     }
     return {
@@ -17032,7 +17171,7 @@ gpgsig`));
   async function packObjects({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oids,
     write = false,
     cache = {}
@@ -17064,7 +17203,7 @@ gpgsig`));
     onAuthSuccess,
     onAuthFailure,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     url,
     remote,
@@ -17136,7 +17275,7 @@ gpgsig`));
     fs: fs2,
     cache,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     start,
     finish
   }) {
@@ -17183,7 +17322,7 @@ gpgsig`));
     fs: fs2,
     cache,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oids
   }) {
     const visited = new Set;
@@ -17476,7 +17615,7 @@ gpgsig`));
     onAuthFailure,
     onPrePush,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     remoteRef,
     remote = "origin",
@@ -17550,7 +17689,7 @@ gpgsig`));
   async function readBlob({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     filepath,
     cache = {}
@@ -17576,7 +17715,7 @@ gpgsig`));
   async function readCommit({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     cache = {}
   }) {
@@ -17617,7 +17756,7 @@ gpgsig`));
   async function readNote({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref = "refs/notes/commits",
     oid,
     cache = {}
@@ -17644,7 +17783,7 @@ gpgsig`));
   async function readObject({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     format = "parsed",
     filepath = undefined,
@@ -17729,7 +17868,7 @@ gpgsig`));
   async function readTag({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     cache = {}
   }) {
@@ -17753,7 +17892,7 @@ gpgsig`));
   async function readTree({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     oid,
     filepath = undefined,
     cache = {}
@@ -17779,7 +17918,7 @@ gpgsig`));
   async function remove({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     cache = {}
   }) {
@@ -17849,7 +17988,7 @@ gpgsig`));
     fs: _fs,
     onSign,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref = "refs/notes/commits",
     oid,
     author: _author,
@@ -17939,7 +18078,7 @@ gpgsig`));
   async function renameBranch({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     oldref,
     checkout: checkout2 = false
@@ -17969,7 +18108,7 @@ gpgsig`));
   async function resetIndex({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     ref,
     cache = {}
@@ -18016,7 +18155,7 @@ gpgsig`));
         gid: 0,
         size: 0
       };
-      const object = dir && await fs2.read(join32(dir, filepath));
+      const object = dir && await fs2.read(join42(dir, filepath));
       if (object) {
         workdirOid = await hashObject$1({
           gitdir: updatedGitdir,
@@ -18024,7 +18163,7 @@ gpgsig`));
           object
         });
         if (oid === workdirOid) {
-          stats = await fs2.lstat(join32(dir, filepath));
+          stats = await fs2.lstat(join42(dir, filepath));
         }
       }
       await GitIndexManager.acquire({ fs: fs2, gitdir: updatedGitdir, cache }, async function(index2) {
@@ -18041,7 +18180,7 @@ gpgsig`));
   async function resolveRef({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     depth
   }) {
@@ -18066,7 +18205,7 @@ gpgsig`));
   async function setConfig({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     path,
     value,
     append = false
@@ -18135,7 +18274,7 @@ gpgsig`));
     return lock$3.acquire(ref, callback);
   }
   async function checkAndWriteBlob(fs2, gitdir, dir, filepath, oid = null) {
-    const currentFilepath = join32(dir, filepath);
+    const currentFilepath = join42(dir, filepath);
     const stats = await fs2.lstat(currentFilepath);
     if (!stats)
       throw new NotFoundError(currentFilepath);
@@ -18298,7 +18437,7 @@ gpgsig`));
               stageUpdated.push({
                 filepath,
                 oid,
-                stats: await fs2.lstat(join32(dir, filepath))
+                stats: await fs2.lstat(join42(dir, filepath))
               });
             return {
               method: "write",
@@ -18311,7 +18450,7 @@ gpgsig`));
     });
     await acquireLock$1({ fs: fs2, gitdir, dirRemoved, ops }, async () => {
       for (const op of ops) {
-        const currentFilepath = join32(dir, op.filepath);
+        const currentFilepath = join42(dir, op.filepath);
         switch (op.method) {
           case "rmdir":
             await fs2.rmdir(currentFilepath);
@@ -18347,7 +18486,7 @@ gpgsig`));
   }
 
   class GitStashManager {
-    constructor({ fs: fs2, dir, gitdir = join32(dir, ".git") }) {
+    constructor({ fs: fs2, dir, gitdir = join42(dir, ".git") }) {
       Object.assign(this, {
         fs: fs2,
         dir,
@@ -18362,10 +18501,10 @@ gpgsig`));
       return "logs/refs/stash";
     }
     get refStashPath() {
-      return join32(this.gitdir, GitStashManager.refStash);
+      return join42(this.gitdir, GitStashManager.refStash);
     }
     get refLogsStashPath() {
-      return join32(this.gitdir, GitStashManager.refLogsStash);
+      return join42(this.gitdir, GitStashManager.refLogsStash);
     }
     async getAuthor() {
       if (!this._author) {
@@ -18610,7 +18749,7 @@ gpgsig`));
   async function stash({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     op = "push",
     message = "",
     refIdx = 0
@@ -18633,7 +18772,7 @@ gpgsig`));
       const _fs = new FileSystem(fs2);
       const updatedGitdir = await discoverGitdir({ fsp: _fs, dotgit: gitdir });
       const folders = ["refs", "logs", "logs/refs"];
-      folders.map((f) => join32(updatedGitdir, f)).forEach(async (folder) => {
+      folders.map((f) => join42(updatedGitdir, f)).forEach(async (folder) => {
         if (!await _fs.exists(folder)) {
           await _fs.mkdir(folder);
         }
@@ -18660,7 +18799,7 @@ gpgsig`));
   async function status({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     filepath,
     cache = {}
   }) {
@@ -18694,7 +18833,7 @@ gpgsig`));
         }
         return null;
       });
-      const stats = await fs2.lstat(join32(dir, filepath));
+      const stats = await fs2.lstat(join42(dir, filepath));
       const H = treeOid !== null;
       const I = indexEntry !== null;
       const W = stats !== null;
@@ -18702,7 +18841,7 @@ gpgsig`));
         if (I && !compareStats(indexEntry, stats)) {
           return indexEntry.oid;
         } else {
-          const object = await fs2.read(join32(dir, filepath));
+          const object = await fs2.read(join42(dir, filepath));
           const workdirOid = await hashObject$1({
             gitdir: updatedGitdir,
             type: "blob",
@@ -18795,7 +18934,7 @@ gpgsig`));
   async function statusMatrix({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref = "HEAD",
     filepaths = ["."],
     filter,
@@ -18872,7 +19011,7 @@ gpgsig`));
   async function tag({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     object,
     force = false
@@ -18904,7 +19043,7 @@ gpgsig`));
   async function updateIndex$1({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     cache = {},
     filepath,
     oid,
@@ -18922,7 +19061,7 @@ gpgsig`));
       if (remove2) {
         return await GitIndexManager.acquire({ fs: fs2, gitdir: updatedGitdir, cache }, async function(index2) {
           if (!force) {
-            const fileStats2 = await fs2.lstat(join32(dir, filepath));
+            const fileStats2 = await fs2.lstat(join42(dir, filepath));
             if (fileStats2) {
               if (fileStats2.isDirectory()) {
                 throw new InvalidFilepathError("directory");
@@ -18939,7 +19078,7 @@ gpgsig`));
       }
       let fileStats;
       if (!oid) {
-        fileStats = await fs2.lstat(join32(dir, filepath));
+        fileStats = await fs2.lstat(join42(dir, filepath));
         if (!fileStats) {
           throw new NotFoundError(`file at "${filepath}" on disk and "remove" not set`);
         }
@@ -18954,7 +19093,7 @@ gpgsig`));
         let stats;
         if (!oid) {
           stats = fileStats;
-          const object = stats.isSymbolicLink() ? await fs2.readlink(join32(dir, filepath)) : await fs2.read(join32(dir, filepath));
+          const object = stats.isSymbolicLink() ? await fs2.readlink(join42(dir, filepath)) : await fs2.read(join42(dir, filepath));
           oid = await _writeObject({
             fs: fs2,
             gitdir: updatedGitdir,
@@ -18997,7 +19136,7 @@ gpgsig`));
   async function walk({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     trees,
     map,
     reduce,
@@ -19025,7 +19164,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function writeBlob({ fs: fs2, dir, gitdir = join32(dir, ".git"), blob }) {
+  async function writeBlob({ fs: fs2, dir, gitdir = join42(dir, ".git"), blob }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -19047,7 +19186,7 @@ gpgsig`));
   async function writeCommit({
     fs: fs2,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     commit: commit2
   }) {
     try {
@@ -19069,7 +19208,7 @@ gpgsig`));
   async function writeObject({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     type,
     object,
     format = "parsed",
@@ -19115,7 +19254,7 @@ gpgsig`));
   async function writeRef({
     fs: _fs,
     dir,
-    gitdir = join32(dir, ".git"),
+    gitdir = join42(dir, ".git"),
     ref,
     value,
     force = false,
@@ -19170,7 +19309,7 @@ gpgsig`));
     });
     return oid;
   }
-  async function writeTag({ fs: fs2, dir, gitdir = join32(dir, ".git"), tag: tag2 }) {
+  async function writeTag({ fs: fs2, dir, gitdir = join42(dir, ".git"), tag: tag2 }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -19187,7 +19326,7 @@ gpgsig`));
       throw err;
     }
   }
-  async function writeTree({ fs: fs2, dir, gitdir = join32(dir, ".git"), tree }) {
+  async function writeTree({ fs: fs2, dir, gitdir = join42(dir, ".git"), tree }) {
     try {
       assertParameter("fs", fs2);
       assertParameter("gitdir", gitdir);
@@ -22645,13 +22784,13 @@ var require_readable = __commonJS((exports, module) => {
     return state[kPaused] === true || state.flowing === false;
   };
   Readable.prototype.setEncoding = function(enc) {
-    const decoder3 = new StringDecoder(enc);
-    this._readableState.decoder = decoder3;
+    const decoder4 = new StringDecoder(enc);
+    this._readableState.decoder = decoder4;
     this._readableState.encoding = this._readableState.decoder.encoding;
     const buffer = this._readableState.buffer;
     let content = "";
     for (const data of buffer) {
-      content += decoder3.write(data);
+      content += decoder4.write(data);
     }
     buffer.clear();
     if (content !== "")
@@ -25727,12 +25866,6 @@ var require_ours = __commonJS((exports, module) => {
   }
   module.exports.default = module.exports;
 });
-function isRemoteConfig(config) {
-  return config !== undefined && "endpoint" in config;
-}
-function isGitConfig(config) {
-  return config !== undefined && "type" in config && config.type === "git";
-}
 
 class ResourceXError3 extends Error {
   constructor(message, options) {
@@ -26948,9 +27081,81 @@ async function unpackTar3(archive, options = {}) {
 var gzipAsync22 = promisify22(gzip22);
 var gunzipAsync22 = promisify22(gunzip22);
 
-class RXCImpl3 {
+class RXPImpl3 {
+  _files;
+  _pathsCache = null;
+  _treeCache = null;
+  constructor(files) {
+    this._files = files;
+  }
+  paths() {
+    if (this._pathsCache) {
+      return this._pathsCache;
+    }
+    this._pathsCache = Array.from(this._files.keys()).sort();
+    return this._pathsCache;
+  }
+  tree() {
+    if (this._treeCache) {
+      return this._treeCache;
+    }
+    const root = new Map;
+    for (const path of this._files.keys()) {
+      const parts = path.split("/");
+      let currentLevel = root;
+      for (let i = 0;i < parts.length; i++) {
+        const part = parts[i];
+        const isFile = i === parts.length - 1;
+        if (!currentLevel.has(part)) {
+          const treeNode2 = {
+            node: {
+              name: part,
+              type: isFile ? "file" : "directory",
+              children: isFile ? undefined : []
+            },
+            children: new Map
+          };
+          currentLevel.set(part, treeNode2);
+        }
+        const treeNode = currentLevel.get(part);
+        if (!isFile) {
+          currentLevel = treeNode.children;
+        }
+      }
+    }
+    const convertToPathNodes = (level) => {
+      return Array.from(level.values()).map((treeNode) => {
+        if (treeNode.node.type === "directory" && treeNode.children.size > 0) {
+          treeNode.node.children = convertToPathNodes(treeNode.children);
+        }
+        return treeNode.node;
+      });
+    };
+    this._treeCache = convertToPathNodes(root);
+    return this._treeCache;
+  }
+  async file(path) {
+    const content = this._files.get(path);
+    if (!content) {
+      throw new ContentError3(`file not found: ${path}`);
+    }
+    return content;
+  }
+  async files() {
+    return new Map(this._files);
+  }
+  async pack() {
+    const filesRecord = {};
+    for (const [path, content] of this._files) {
+      filesRecord[path] = content;
+    }
+    return createRXA3(filesRecord);
+  }
+}
+
+class RXAImpl3 {
   _buffer;
-  _filesCache = null;
+  _rxpCache = null;
   constructor(buffer) {
     this._buffer = buffer;
   }
@@ -26966,17 +27171,9 @@ class RXCImpl3 {
   async buffer() {
     return this._buffer;
   }
-  async file(path) {
-    const filesMap = await this.files();
-    const content = filesMap.get(path);
-    if (!content) {
-      throw new ContentError3(`file not found: ${path}`);
-    }
-    return content;
-  }
-  async files() {
-    if (this._filesCache) {
-      return this._filesCache;
+  async extract() {
+    if (this._rxpCache) {
+      return this._rxpCache;
     }
     const tarBuffer = await gunzipAsync22(this._buffer);
     const entries = await unpackTar3(tarBuffer);
@@ -26986,16 +27183,16 @@ class RXCImpl3 {
         filesMap.set(entry.header.name, Buffer.from(entry.data));
       }
     }
-    this._filesCache = filesMap;
-    return filesMap;
+    this._rxpCache = new RXPImpl3(filesMap);
+    return this._rxpCache;
   }
 }
-function isArchiveInput3(input) {
-  return "archive" in input && Buffer.isBuffer(input.archive);
+function isBufferInput3(input) {
+  return "buffer" in input && Buffer.isBuffer(input.buffer);
 }
-async function createRXC3(input) {
-  if (isArchiveInput3(input)) {
-    return new RXCImpl3(input.archive);
+async function createRXA3(input) {
+  if (isBufferInput3(input)) {
+    return new RXAImpl3(input.buffer);
   }
   const entries = Object.entries(input).map(([name, content]) => {
     const body = typeof content === "string" ? content : content instanceof Uint8Array ? content : new Uint8Array(content);
@@ -27007,7 +27204,7 @@ async function createRXC3(input) {
   });
   const tarBuffer = await packTar3(entries);
   const gzipBuffer = await gzipAsync22(Buffer.from(tarBuffer));
-  return new RXCImpl3(gzipBuffer);
+  return new RXAImpl3(gzipBuffer);
 }
 
 class ResourceTypeError2 extends ResourceXError22 {
@@ -27018,13 +27215,13 @@ class ResourceTypeError2 extends ResourceXError22 {
 }
 var textSerializer2 = {
   async serialize(rxr) {
-    return rxr.content.buffer();
+    return rxr.archive.buffer();
   },
   async deserialize(data, manifest) {
     return {
       locator: parseRXL22(manifest.toLocator()),
       manifest,
-      content: await createRXC3({ archive: data })
+      archive: await createRXA3({ buffer: data })
     };
   }
 };
@@ -27035,7 +27232,8 @@ var textResolver2 = {
       resource: rxr,
       schema: undefined,
       execute: async () => {
-        const buffer = await rxr.content.file("content");
+        const pkg = await rxr.archive.extract();
+        const buffer = await pkg.file("content");
         return buffer.toString("utf-8");
       }
     };
@@ -27050,13 +27248,13 @@ var textType2 = {
 };
 var jsonSerializer2 = {
   async serialize(rxr) {
-    return rxr.content.buffer();
+    return rxr.archive.buffer();
   },
   async deserialize(data, manifest) {
     return {
       locator: parseRXL22(manifest.toLocator()),
       manifest,
-      content: await createRXC3({ archive: data })
+      archive: await createRXA3({ buffer: data })
     };
   }
 };
@@ -27067,7 +27265,8 @@ var jsonResolver2 = {
       resource: rxr,
       schema: undefined,
       execute: async () => {
-        const buffer = await rxr.content.file("content");
+        const pkg = await rxr.archive.extract();
+        const buffer = await pkg.file("content");
         return JSON.parse(buffer.toString("utf-8"));
       }
     };
@@ -27082,13 +27281,13 @@ var jsonType2 = {
 };
 var binarySerializer2 = {
   async serialize(rxr) {
-    return rxr.content.buffer();
+    return rxr.archive.buffer();
   },
   async deserialize(data, manifest) {
     return {
       locator: parseRXL22(manifest.toLocator()),
       manifest,
-      content: await createRXC3({ archive: data })
+      archive: await createRXA3({ buffer: data })
     };
   }
 };
@@ -27099,7 +27298,8 @@ var binaryResolver2 = {
       resource: rxr,
       schema: undefined,
       execute: async () => {
-        return rxr.content.file("content");
+        const pkg = await rxr.archive.extract();
+        return pkg.file("content");
       }
     };
   }
@@ -27698,107 +27898,1473 @@ class ARP {
 function createARP(config) {
   return new ARP(config);
 }
-var DEFAULT_PATH = `${homedir()}/.resourcex`;
 
-class LocalRegistry {
-  basePath;
-  typeHandler;
-  arp;
-  constructor(config) {
-    this.basePath = config?.path ?? DEFAULT_PATH;
-    this.typeHandler = TypeHandlerChain2.create();
-    this.arp = createARP();
-    if (config?.types) {
-      for (const type of config.types) {
-        this.typeHandler.register(type);
-      }
-    }
+class ResourceXError32 extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ResourceXError";
   }
-  supportType(type) {
-    this.typeHandler.register(type);
+}
+
+class ManifestError22 extends ResourceXError32 {
+  constructor(message) {
+    super(message);
+    this.name = "ManifestError";
   }
-  toArpUrl(filePath) {
-    return `arp:binary:file://${filePath}`;
+}
+
+class ContentError22 extends ResourceXError32 {
+  constructor(message) {
+    super(message);
+    this.name = "ContentError";
   }
-  buildPath(locator, area) {
-    const rxl = typeof locator === "string" ? parseRXL3(locator) : locator;
-    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    const version = rxl.version ?? "latest";
-    if (area === "local") {
-      return join2(this.basePath, "local", resourceName, version);
-    } else {
-      const domain = rxl.domain ?? "localhost";
-      let path = join2(this.basePath, "cache", domain);
-      if (rxl.path) {
-        path = join2(path, rxl.path);
+}
+
+class RXLImpl32 {
+  domain;
+  path;
+  name;
+  type;
+  version;
+  constructor(parts) {
+    this.domain = parts.domain;
+    this.path = parts.path;
+    this.name = parts.name;
+    this.type = parts.type;
+    this.version = parts.version;
+  }
+  toString() {
+    let result = "";
+    if (this.domain) {
+      result += this.domain + "/";
+      if (this.path) {
+        result += this.path + "/";
       }
-      return join2(path, resourceName, version);
     }
-  }
-  isLocalOnlyLocator(locator) {
-    const rxl = typeof locator === "string" ? parseRXL3(locator) : locator;
-    return !rxl.domain || rxl.domain === "localhost";
-  }
-  async existsAt(resourcePath) {
-    const manifestPath = join2(resourcePath, "manifest.json");
-    const arl = this.arp.parse(this.toArpUrl(manifestPath));
-    return arl.exists();
-  }
-  async findArea(locator) {
-    const localPath = this.buildPath(locator, "local");
-    if (await this.existsAt(localPath)) {
-      return "local";
+    result += this.name;
+    if (this.type) {
+      result += "." + this.type;
     }
-    const cachePath = this.buildPath(locator, "cache");
-    if (await this.existsAt(cachePath)) {
-      return "cache";
+    if (this.version) {
+      result += "@" + this.version;
     }
-    return null;
+    return result;
   }
-  async loadFrom(resourcePath) {
-    const manifestPath = join2(resourcePath, "manifest.json");
-    const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
-    const manifestResource = await manifestArl.resolve();
-    const manifestContent = manifestResource.content.toString("utf-8");
-    const manifestData = JSON.parse(manifestContent);
-    const manifest = createRXM2(manifestData);
-    const contentPath = join2(resourcePath, "content.tar.gz");
-    const contentArl = this.arp.parse(this.toArpUrl(contentPath));
-    const contentResource = await contentArl.resolve();
-    const data = contentResource.content;
-    return this.typeHandler.deserialize(data, manifest);
+}
+function isDomain32(str) {
+  if (str === "localhost")
+    return true;
+  return str.includes(".");
+}
+function parseRXL32(locator) {
+  let remaining = locator;
+  let version;
+  let type;
+  let domain;
+  let path;
+  let name;
+  const atIndex = remaining.indexOf("@");
+  if (atIndex !== -1) {
+    version = remaining.slice(atIndex + 1);
+    remaining = remaining.slice(0, atIndex);
   }
-  async pull(_locator, _options) {
-    throw new RegistryError("Pull not implemented yet - see issue #018");
+  const segments = remaining.split("/");
+  if (segments.length > 1 && isDomain32(segments[0])) {
+    domain = segments[0];
+    const lastSegment = segments[segments.length - 1];
+    if (segments.length > 2) {
+      path = segments.slice(1, -1).join("/");
+    }
+    remaining = lastSegment;
+  } else {
+    remaining = segments.join("/");
   }
-  async publish(_resource, _options) {
-    throw new RegistryError("Publish not implemented yet - see issue #018");
+  const dotIndex = remaining.lastIndexOf(".");
+  if (dotIndex !== -1) {
+    type = remaining.slice(dotIndex + 1);
+    name = remaining.slice(0, dotIndex);
+  } else {
+    name = remaining;
   }
-  async link(resource) {
-    const locator = resource.manifest.toLocator();
-    const resourcePath = this.buildPath(locator, "local");
-    const dirArl = this.arp.parse(this.toArpUrl(resourcePath));
-    await dirArl.mkdir();
-    const manifestPath = join2(resourcePath, "manifest.json");
-    const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
-    const manifestContent = Buffer.from(JSON.stringify(resource.manifest.toJSON(), null, 2), "utf-8");
-    await manifestArl.deposit(manifestContent);
-    const contentPath = join2(resourcePath, "content.tar.gz");
-    const contentArl = this.arp.parse(this.toArpUrl(contentPath));
-    const serialized = await this.typeHandler.serialize(resource);
-    await contentArl.deposit(serialized);
+  return new RXLImpl32({ domain, path, name, type, version });
+}
+
+class RXMImpl22 {
+  domain;
+  path;
+  name;
+  type;
+  version;
+  constructor(data) {
+    this.domain = data.domain;
+    this.path = data.path;
+    this.name = data.name;
+    this.type = data.type;
+    this.version = data.version;
   }
-  async get(locator) {
-    const area = await this.findArea(locator);
-    if (!area) {
-      throw new RegistryError(`Resource not found: ${locator}`);
+  toLocator() {
+    let result = this.domain + "/";
+    if (this.path) {
+      result += this.path + "/";
     }
-    const resourcePath = this.buildPath(locator, area);
-    return this.loadFrom(resourcePath);
+    result += this.name;
+    result += "." + this.type;
+    result += "@" + this.version;
+    return result;
   }
-  async resolve(locator) {
-    const rxr = await this.get(locator);
-    return this.typeHandler.resolve(rxr);
+  toJSON() {
+    const json = {
+      domain: this.domain,
+      name: this.name,
+      type: this.type,
+      version: this.version
+    };
+    if (this.path !== undefined) {
+      json.path = this.path;
+    }
+    return json;
+  }
+}
+function createRXM22(data) {
+  if (!data.domain) {
+    throw new ManifestError22("domain is required");
+  }
+  if (!data.name) {
+    throw new ManifestError22("name is required");
+  }
+  if (!data.type) {
+    throw new ManifestError22("type is required");
+  }
+  if (!data.version) {
+    throw new ManifestError22("version is required");
+  }
+  return new RXMImpl22({
+    domain: data.domain,
+    path: data.path,
+    name: data.name,
+    type: data.type,
+    version: data.version
+  });
+}
+var BLOCK_SIZE32 = 512;
+var BLOCK_SIZE_MASK22 = 511;
+var DEFAULT_FILE_MODE22 = 420;
+var DEFAULT_DIR_MODE22 = 493;
+var USTAR_NAME_OFFSET22 = 0;
+var USTAR_NAME_SIZE22 = 100;
+var USTAR_MODE_OFFSET22 = 100;
+var USTAR_MODE_SIZE22 = 8;
+var USTAR_UID_OFFSET22 = 108;
+var USTAR_UID_SIZE22 = 8;
+var USTAR_GID_OFFSET22 = 116;
+var USTAR_GID_SIZE22 = 8;
+var USTAR_SIZE_OFFSET22 = 124;
+var USTAR_SIZE_SIZE22 = 12;
+var USTAR_MTIME_OFFSET22 = 136;
+var USTAR_MTIME_SIZE22 = 12;
+var USTAR_CHECKSUM_OFFSET22 = 148;
+var USTAR_CHECKSUM_SIZE22 = 8;
+var USTAR_TYPEFLAG_OFFSET22 = 156;
+var USTAR_TYPEFLAG_SIZE22 = 1;
+var USTAR_LINKNAME_OFFSET22 = 157;
+var USTAR_LINKNAME_SIZE22 = 100;
+var USTAR_MAGIC_OFFSET22 = 257;
+var USTAR_MAGIC_SIZE22 = 6;
+var USTAR_VERSION_OFFSET22 = 263;
+var USTAR_VERSION_SIZE22 = 2;
+var USTAR_UNAME_OFFSET22 = 265;
+var USTAR_UNAME_SIZE22 = 32;
+var USTAR_GNAME_OFFSET22 = 297;
+var USTAR_GNAME_SIZE22 = 32;
+var USTAR_PREFIX_OFFSET22 = 345;
+var USTAR_PREFIX_SIZE22 = 155;
+var USTAR_VERSION22 = "00";
+var USTAR_MAX_UID_GID22 = 2097151;
+var USTAR_MAX_SIZE22 = 8589934591;
+var FILE22 = "file";
+var LINK22 = "link";
+var SYMLINK22 = "symlink";
+var DIRECTORY22 = "directory";
+var TYPEFLAG22 = {
+  file: "0",
+  link: "1",
+  symlink: "2",
+  "character-device": "3",
+  "block-device": "4",
+  directory: "5",
+  fifo: "6",
+  "pax-header": "x",
+  "pax-global-header": "g",
+  "gnu-long-name": "L",
+  "gnu-long-link-name": "K"
+};
+var FLAGTYPE22 = {
+  "0": FILE22,
+  "1": LINK22,
+  "2": SYMLINK22,
+  "3": "character-device",
+  "4": "block-device",
+  "5": DIRECTORY22,
+  "6": "fifo",
+  x: "pax-header",
+  g: "pax-global-header",
+  L: "gnu-long-name",
+  K: "gnu-long-link-name"
+};
+var ZERO_BLOCK32 = new Uint8Array(BLOCK_SIZE32);
+var EMPTY32 = new Uint8Array(0);
+var encoder32 = new TextEncoder;
+var decoder32 = new TextDecoder;
+function writeString22(view, offset, size, value) {
+  if (value)
+    encoder32.encodeInto(value, view.subarray(offset, offset + size));
+}
+function writeOctal22(view, offset, size, value) {
+  if (value === undefined)
+    return;
+  const octalString = value.toString(8).padStart(size - 1, "0");
+  encoder32.encodeInto(octalString, view.subarray(offset, offset + size - 1));
+}
+function readString22(view, offset, size) {
+  const end = view.indexOf(0, offset);
+  const sliceEnd = end === -1 || end > offset + size ? offset + size : end;
+  return decoder32.decode(view.subarray(offset, sliceEnd));
+}
+function readOctal22(view, offset, size) {
+  let value = 0;
+  const end = offset + size;
+  for (let i = offset;i < end; i++) {
+    const charCode = view[i];
+    if (charCode === 0)
+      break;
+    if (charCode === 32)
+      continue;
+    value = value * 8 + (charCode - 48);
+  }
+  return value;
+}
+function readNumeric22(view, offset, size) {
+  if (view[offset] & 128) {
+    let result = 0;
+    result = view[offset] & 127;
+    for (let i = 1;i < size; i++)
+      result = result * 256 + view[offset + i];
+    if (!Number.isSafeInteger(result))
+      throw new Error("TAR number too large");
+    return result;
+  }
+  return readOctal22(view, offset, size);
+}
+var isBodyless22 = (header) => header.type === DIRECTORY22 || header.type === SYMLINK22 || header.type === LINK22;
+async function normalizeBody22(body) {
+  if (body === null || body === undefined)
+    return EMPTY32;
+  if (body instanceof Uint8Array)
+    return body;
+  if (typeof body === "string")
+    return encoder32.encode(body);
+  if (body instanceof ArrayBuffer)
+    return new Uint8Array(body);
+  if (body instanceof Blob)
+    return new Uint8Array(await body.arrayBuffer());
+  throw new TypeError("Unsupported content type for entry body.");
+}
+function transformHeader22(header, options) {
+  const { strip, filter, map } = options;
+  if (!strip && !filter && !map)
+    return header;
+  const h = { ...header };
+  if (strip && strip > 0) {
+    const components = h.name.split("/").filter(Boolean);
+    if (strip >= components.length)
+      return null;
+    const newName = components.slice(strip).join("/");
+    h.name = h.type === DIRECTORY22 && !newName.endsWith("/") ? `${newName}/` : newName;
+    if (h.linkname?.startsWith("/")) {
+      const linkComponents = h.linkname.split("/").filter(Boolean);
+      h.linkname = strip >= linkComponents.length ? "/" : `/${linkComponents.slice(strip).join("/")}`;
+    }
+  }
+  if (filter?.(h) === false)
+    return null;
+  const result = map ? map(h) : h;
+  if (result && (!result.name || !result.name.trim() || result.name === "." || result.name === "/"))
+    return null;
+  return result;
+}
+var CHECKSUM_SPACE22 = 32;
+var ASCII_ZERO22 = 48;
+function validateChecksum22(block) {
+  const stored = readOctal22(block, USTAR_CHECKSUM_OFFSET22, USTAR_CHECKSUM_SIZE22);
+  let sum = 0;
+  for (let i = 0;i < block.length; i++)
+    if (i >= USTAR_CHECKSUM_OFFSET22 && i < USTAR_CHECKSUM_OFFSET22 + USTAR_CHECKSUM_SIZE22)
+      sum += CHECKSUM_SPACE22;
+    else
+      sum += block[i];
+  return stored === sum;
+}
+function writeChecksum22(block) {
+  block.fill(CHECKSUM_SPACE22, USTAR_CHECKSUM_OFFSET22, USTAR_CHECKSUM_OFFSET22 + USTAR_CHECKSUM_SIZE22);
+  let checksum = 0;
+  for (const byte of block)
+    checksum += byte;
+  for (let i = USTAR_CHECKSUM_OFFSET22 + 6 - 1;i >= USTAR_CHECKSUM_OFFSET22; i--) {
+    block[i] = (checksum & 7) + ASCII_ZERO22;
+    checksum >>= 3;
+  }
+  block[USTAR_CHECKSUM_OFFSET22 + 6] = 0;
+  block[USTAR_CHECKSUM_OFFSET22 + 7] = CHECKSUM_SPACE22;
+}
+function generatePax22(header) {
+  const paxRecords = {};
+  if (header.name.length > USTAR_NAME_SIZE22) {
+    if (findUstarSplit22(header.name) === null)
+      paxRecords.path = header.name;
+  }
+  if (header.linkname && header.linkname.length > USTAR_NAME_SIZE22)
+    paxRecords.linkpath = header.linkname;
+  if (header.uname && header.uname.length > USTAR_UNAME_SIZE22)
+    paxRecords.uname = header.uname;
+  if (header.gname && header.gname.length > USTAR_GNAME_SIZE22)
+    paxRecords.gname = header.gname;
+  if (header.uid != null && header.uid > USTAR_MAX_UID_GID22)
+    paxRecords.uid = String(header.uid);
+  if (header.gid != null && header.gid > USTAR_MAX_UID_GID22)
+    paxRecords.gid = String(header.gid);
+  if (header.size != null && header.size > USTAR_MAX_SIZE22)
+    paxRecords.size = String(header.size);
+  if (header.pax)
+    Object.assign(paxRecords, header.pax);
+  const paxEntries = Object.entries(paxRecords);
+  if (paxEntries.length === 0)
+    return null;
+  const paxBody = encoder32.encode(paxEntries.map(([key, value]) => {
+    const record = `${key}=${value}
+`;
+    const partLength = encoder32.encode(record).length + 1;
+    let totalLength = partLength + String(partLength).length;
+    totalLength = partLength + String(totalLength).length;
+    return `${totalLength} ${record}`;
+  }).join(""));
+  return {
+    paxHeader: createTarHeader22({
+      name: decoder32.decode(encoder32.encode(`PaxHeader/${header.name}`).slice(0, 100)),
+      size: paxBody.length,
+      type: "pax-header",
+      mode: 420,
+      mtime: header.mtime,
+      uname: header.uname,
+      gname: header.gname,
+      uid: header.uid,
+      gid: header.gid
+    }),
+    paxBody
+  };
+}
+function findUstarSplit22(path) {
+  if (path.length <= USTAR_NAME_SIZE22)
+    return null;
+  const minSlashIndex = path.length - USTAR_NAME_SIZE22 - 1;
+  const slashIndex = path.lastIndexOf("/", USTAR_PREFIX_SIZE22);
+  if (slashIndex > 0 && slashIndex >= minSlashIndex)
+    return {
+      prefix: path.slice(0, slashIndex),
+      name: path.slice(slashIndex + 1)
+    };
+  return null;
+}
+function createTarHeader22(header) {
+  const view = new Uint8Array(BLOCK_SIZE32);
+  const size = isBodyless22(header) ? 0 : header.size ?? 0;
+  let name = header.name;
+  let prefix = "";
+  if (!header.pax?.path) {
+    const split = findUstarSplit22(name);
+    if (split) {
+      name = split.name;
+      prefix = split.prefix;
+    }
+  }
+  writeString22(view, USTAR_NAME_OFFSET22, USTAR_NAME_SIZE22, name);
+  writeOctal22(view, USTAR_MODE_OFFSET22, USTAR_MODE_SIZE22, header.mode ?? (header.type === DIRECTORY22 ? DEFAULT_DIR_MODE22 : DEFAULT_FILE_MODE22));
+  writeOctal22(view, USTAR_UID_OFFSET22, USTAR_UID_SIZE22, header.uid ?? 0);
+  writeOctal22(view, USTAR_GID_OFFSET22, USTAR_GID_SIZE22, header.gid ?? 0);
+  writeOctal22(view, USTAR_SIZE_OFFSET22, USTAR_SIZE_SIZE22, size);
+  writeOctal22(view, USTAR_MTIME_OFFSET22, USTAR_MTIME_SIZE22, Math.floor((header.mtime?.getTime() ?? Date.now()) / 1000));
+  writeString22(view, USTAR_TYPEFLAG_OFFSET22, USTAR_TYPEFLAG_SIZE22, TYPEFLAG22[header.type ?? FILE22]);
+  writeString22(view, USTAR_LINKNAME_OFFSET22, USTAR_LINKNAME_SIZE22, header.linkname);
+  writeString22(view, USTAR_MAGIC_OFFSET22, USTAR_MAGIC_SIZE22, "ustar\x00");
+  writeString22(view, USTAR_VERSION_OFFSET22, USTAR_VERSION_SIZE22, USTAR_VERSION22);
+  writeString22(view, USTAR_UNAME_OFFSET22, USTAR_UNAME_SIZE22, header.uname);
+  writeString22(view, USTAR_GNAME_OFFSET22, USTAR_GNAME_SIZE22, header.gname);
+  writeString22(view, USTAR_PREFIX_OFFSET22, USTAR_PREFIX_SIZE22, prefix);
+  writeChecksum22(view);
+  return view;
+}
+function parseUstarHeader22(block, strict) {
+  if (strict && !validateChecksum22(block))
+    throw new Error("Invalid tar header checksum.");
+  const typeflag = readString22(block, USTAR_TYPEFLAG_OFFSET22, USTAR_TYPEFLAG_SIZE22);
+  const header = {
+    name: readString22(block, USTAR_NAME_OFFSET22, USTAR_NAME_SIZE22),
+    mode: readOctal22(block, USTAR_MODE_OFFSET22, USTAR_MODE_SIZE22),
+    uid: readNumeric22(block, USTAR_UID_OFFSET22, USTAR_UID_SIZE22),
+    gid: readNumeric22(block, USTAR_GID_OFFSET22, USTAR_GID_SIZE22),
+    size: readNumeric22(block, USTAR_SIZE_OFFSET22, USTAR_SIZE_SIZE22),
+    mtime: /* @__PURE__ */ new Date(readNumeric22(block, USTAR_MTIME_OFFSET22, USTAR_MTIME_SIZE22) * 1000),
+    type: FLAGTYPE22[typeflag] || FILE22,
+    linkname: readString22(block, USTAR_LINKNAME_OFFSET22, USTAR_LINKNAME_SIZE22)
+  };
+  const magic = readString22(block, USTAR_MAGIC_OFFSET22, USTAR_MAGIC_SIZE22);
+  if (magic.trim() === "ustar") {
+    header.uname = readString22(block, USTAR_UNAME_OFFSET22, USTAR_UNAME_SIZE22);
+    header.gname = readString22(block, USTAR_GNAME_OFFSET22, USTAR_GNAME_SIZE22);
+  }
+  if (magic === "ustar")
+    header.prefix = readString22(block, USTAR_PREFIX_OFFSET22, USTAR_PREFIX_SIZE22);
+  return header;
+}
+var PAX_MAPPING22 = {
+  path: ["name", (v) => v],
+  linkpath: ["linkname", (v) => v],
+  size: ["size", (v) => parseInt(v, 10)],
+  mtime: ["mtime", parseFloat],
+  uid: ["uid", (v) => parseInt(v, 10)],
+  gid: ["gid", (v) => parseInt(v, 10)],
+  uname: ["uname", (v) => v],
+  gname: ["gname", (v) => v]
+};
+function parsePax22(buffer) {
+  const decoder$1 = new TextDecoder("utf-8");
+  const overrides = {};
+  const pax = {};
+  let offset = 0;
+  while (offset < buffer.length) {
+    const spaceIndex = buffer.indexOf(32, offset);
+    if (spaceIndex === -1)
+      break;
+    const length = parseInt(decoder$1.decode(buffer.subarray(offset, spaceIndex)), 10);
+    if (Number.isNaN(length) || length === 0)
+      break;
+    const recordEnd = offset + length;
+    const [key, value] = decoder$1.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1)).split("=", 2);
+    if (key && value !== undefined) {
+      pax[key] = value;
+      const mapping = PAX_MAPPING22[key];
+      if (mapping) {
+        const [targetKey, parser] = mapping;
+        const parsedValue = parser(value);
+        if (typeof parsedValue === "string" || !Number.isNaN(parsedValue))
+          overrides[targetKey] = parsedValue;
+      }
+    }
+    offset = recordEnd;
+  }
+  if (Object.keys(pax).length > 0)
+    overrides.pax = pax;
+  return overrides;
+}
+function applyOverrides22(header, overrides) {
+  if (overrides.name !== undefined)
+    header.name = overrides.name;
+  if (overrides.linkname !== undefined)
+    header.linkname = overrides.linkname;
+  if (overrides.size !== undefined)
+    header.size = overrides.size;
+  if (overrides.mtime !== undefined)
+    header.mtime = /* @__PURE__ */ new Date(overrides.mtime * 1000);
+  if (overrides.uid !== undefined)
+    header.uid = overrides.uid;
+  if (overrides.gid !== undefined)
+    header.gid = overrides.gid;
+  if (overrides.uname !== undefined)
+    header.uname = overrides.uname;
+  if (overrides.gname !== undefined)
+    header.gname = overrides.gname;
+  if (overrides.pax)
+    header.pax = Object.assign({}, header.pax ?? {}, overrides.pax);
+}
+function getMetaParser22(type) {
+  switch (type) {
+    case "pax-global-header":
+    case "pax-header":
+      return parsePax22;
+    case "gnu-long-name":
+      return (data) => ({ name: readString22(data, 0, data.length) });
+    case "gnu-long-link-name":
+      return (data) => ({ linkname: readString22(data, 0, data.length) });
+    default:
+      return;
+  }
+}
+function getHeaderBlocks22(header) {
+  const base = createTarHeader22(header);
+  const pax = generatePax22(header);
+  if (!pax)
+    return [base];
+  const paxPadding = -pax.paxBody.length & BLOCK_SIZE_MASK22;
+  const paddingBlocks = paxPadding > 0 ? [ZERO_BLOCK32.subarray(0, paxPadding)] : [];
+  return [
+    pax.paxHeader,
+    pax.paxBody,
+    ...paddingBlocks,
+    base
+  ];
+}
+var EOF_BUFFER32 = new Uint8Array(BLOCK_SIZE32 * 2);
+function createTarPacker32(onData, onError, onFinalize) {
+  let currentHeader = null;
+  let bytesWritten = 0;
+  let finalized = false;
+  return {
+    add(header) {
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("No new tar entries after finalize.");
+        onError(error);
+        throw error;
+      }
+      if (currentHeader !== null) {
+        const error = /* @__PURE__ */ new Error("Previous entry must be completed before adding a new one");
+        onError(error);
+        throw error;
+      }
+      try {
+        const size = isBodyless22(header) ? 0 : header.size ?? 0;
+        const headerBlocks = getHeaderBlocks22({
+          ...header,
+          size
+        });
+        for (const block of headerBlocks)
+          onData(block);
+        currentHeader = {
+          ...header,
+          size
+        };
+        bytesWritten = 0;
+      } catch (error) {
+        onError(error);
+      }
+    },
+    write(chunk) {
+      if (!currentHeader) {
+        const error = /* @__PURE__ */ new Error("No active tar entry.");
+        onError(error);
+        throw error;
+      }
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("Cannot write data after finalize.");
+        onError(error);
+        throw error;
+      }
+      const newTotal = bytesWritten + chunk.length;
+      if (newTotal > currentHeader.size) {
+        const error = /* @__PURE__ */ new Error(`"${currentHeader.name}" exceeds given size of ${currentHeader.size} bytes.`);
+        onError(error);
+        throw error;
+      }
+      try {
+        bytesWritten = newTotal;
+        onData(chunk);
+      } catch (error) {
+        onError(error);
+      }
+    },
+    endEntry() {
+      if (!currentHeader) {
+        const error = /* @__PURE__ */ new Error("No active entry to end.");
+        onError(error);
+        throw error;
+      }
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("Cannot end entry after finalize.");
+        onError(error);
+        throw error;
+      }
+      try {
+        if (bytesWritten !== currentHeader.size) {
+          const error = /* @__PURE__ */ new Error(`Size mismatch for "${currentHeader.name}".`);
+          onError(error);
+          throw error;
+        }
+        const paddingSize = -currentHeader.size & BLOCK_SIZE_MASK22;
+        if (paddingSize > 0)
+          onData(new Uint8Array(paddingSize));
+        currentHeader = null;
+        bytesWritten = 0;
+      } catch (error) {
+        onError(error);
+        throw error;
+      }
+    },
+    finalize() {
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("Archive has already been finalized");
+        onError(error);
+        throw error;
+      }
+      if (currentHeader !== null) {
+        const error = /* @__PURE__ */ new Error("Cannot finalize while an entry is still active");
+        onError(error);
+        throw error;
+      }
+      try {
+        onData(EOF_BUFFER32);
+        finalized = true;
+        if (onFinalize)
+          onFinalize();
+      } catch (error) {
+        onError(error);
+      }
+    }
+  };
+}
+var INITIAL_CAPACITY22 = 256;
+function createChunkQueue22() {
+  let chunks = new Array(INITIAL_CAPACITY22);
+  let capacityMask = chunks.length - 1;
+  let head = 0;
+  let tail = 0;
+  let totalAvailable = 0;
+  const consumeFromHead = (count) => {
+    const chunk = chunks[head];
+    if (count === chunk.length) {
+      chunks[head] = EMPTY32;
+      head = head + 1 & capacityMask;
+    } else
+      chunks[head] = chunk.subarray(count);
+    totalAvailable -= count;
+    if (totalAvailable === 0 && chunks.length > INITIAL_CAPACITY22) {
+      chunks = new Array(INITIAL_CAPACITY22);
+      capacityMask = INITIAL_CAPACITY22 - 1;
+      head = 0;
+      tail = 0;
+    }
+  };
+  function pull(bytes, callback) {
+    if (callback) {
+      let fed = 0;
+      let remaining$1 = Math.min(bytes, totalAvailable);
+      while (remaining$1 > 0) {
+        const chunk = chunks[head];
+        const toFeed = Math.min(remaining$1, chunk.length);
+        const segment = toFeed === chunk.length ? chunk : chunk.subarray(0, toFeed);
+        consumeFromHead(toFeed);
+        remaining$1 -= toFeed;
+        fed += toFeed;
+        if (!callback(segment))
+          break;
+      }
+      return fed;
+    }
+    if (totalAvailable < bytes)
+      return null;
+    if (bytes === 0)
+      return EMPTY32;
+    const firstChunk = chunks[head];
+    if (firstChunk.length >= bytes) {
+      const view = firstChunk.length === bytes ? firstChunk : firstChunk.subarray(0, bytes);
+      consumeFromHead(bytes);
+      return view;
+    }
+    const result = new Uint8Array(bytes);
+    let copied = 0;
+    let remaining = bytes;
+    while (remaining > 0) {
+      const chunk = chunks[head];
+      const toCopy = Math.min(remaining, chunk.length);
+      result.set(toCopy === chunk.length ? chunk : chunk.subarray(0, toCopy), copied);
+      copied += toCopy;
+      remaining -= toCopy;
+      consumeFromHead(toCopy);
+    }
+    return result;
+  }
+  return {
+    push: (chunk) => {
+      if (chunk.length === 0)
+        return;
+      let nextTail = tail + 1 & capacityMask;
+      if (nextTail === head) {
+        const oldLen = chunks.length;
+        const newLen = oldLen * 2;
+        const newChunks = new Array(newLen);
+        const count = tail - head + oldLen & oldLen - 1;
+        if (head < tail)
+          for (let i = 0;i < count; i++)
+            newChunks[i] = chunks[head + i];
+        else if (count > 0) {
+          const firstPart = oldLen - head;
+          for (let i = 0;i < firstPart; i++)
+            newChunks[i] = chunks[head + i];
+          for (let i = 0;i < tail; i++)
+            newChunks[firstPart + i] = chunks[i];
+        }
+        chunks = newChunks;
+        capacityMask = newLen - 1;
+        head = 0;
+        tail = count;
+        nextTail = tail + 1 & capacityMask;
+      }
+      chunks[tail] = chunk;
+      tail = nextTail;
+      totalAvailable += chunk.length;
+    },
+    available: () => totalAvailable,
+    peek: (bytes) => {
+      if (totalAvailable < bytes)
+        return null;
+      if (bytes === 0)
+        return EMPTY32;
+      const firstChunk = chunks[head];
+      if (firstChunk.length >= bytes)
+        return firstChunk.length === bytes ? firstChunk : firstChunk.subarray(0, bytes);
+      const result = new Uint8Array(bytes);
+      let copied = 0;
+      let index = head;
+      while (copied < bytes) {
+        const chunk = chunks[index];
+        const toCopy = Math.min(bytes - copied, chunk.length);
+        if (toCopy === chunk.length)
+          result.set(chunk, copied);
+        else
+          result.set(chunk.subarray(0, toCopy), copied);
+        copied += toCopy;
+        index = index + 1 & capacityMask;
+      }
+      return result;
+    },
+    discard: (bytes) => {
+      if (bytes > totalAvailable)
+        throw new Error("Too many bytes consumed");
+      if (bytes === 0)
+        return;
+      let remaining = bytes;
+      while (remaining > 0) {
+        const chunk = chunks[head];
+        const toConsume = Math.min(remaining, chunk.length);
+        consumeFromHead(toConsume);
+        remaining -= toConsume;
+      }
+    },
+    pull
+  };
+}
+var STATE_HEADER22 = 0;
+var STATE_BODY22 = 1;
+var truncateErr22 = /* @__PURE__ */ new Error("Tar archive is truncated.");
+function createUnpacker22(options = {}) {
+  const strict = options.strict ?? false;
+  const { available, peek, push, discard, pull } = createChunkQueue22();
+  let state = STATE_HEADER22;
+  let ended = false;
+  let done = false;
+  let eof = false;
+  let currentEntry = null;
+  const paxGlobals = {};
+  let nextEntryOverrides = {};
+  const unpacker = {
+    isEntryActive: () => state === STATE_BODY22,
+    isBodyComplete: () => !currentEntry || currentEntry.remaining === 0,
+    write(chunk) {
+      if (ended)
+        throw new Error("Archive already ended.");
+      push(chunk);
+    },
+    end() {
+      ended = true;
+    },
+    readHeader() {
+      if (state !== STATE_HEADER22)
+        throw new Error("Cannot read header while an entry is active");
+      if (done)
+        return;
+      while (!done) {
+        if (available() < BLOCK_SIZE32) {
+          if (ended) {
+            if (available() > 0 && strict)
+              throw truncateErr22;
+            done = true;
+            return;
+          }
+          return null;
+        }
+        const headerBlock = peek(BLOCK_SIZE32);
+        if (isZeroBlock22(headerBlock)) {
+          if (available() < BLOCK_SIZE32 * 2) {
+            if (ended) {
+              if (strict)
+                throw truncateErr22;
+              done = true;
+              return;
+            }
+            return null;
+          }
+          if (isZeroBlock22(peek(BLOCK_SIZE32 * 2).subarray(BLOCK_SIZE32))) {
+            discard(BLOCK_SIZE32 * 2);
+            done = true;
+            eof = true;
+            return;
+          }
+          if (strict)
+            throw new Error("Invalid tar header.");
+          discard(BLOCK_SIZE32);
+          continue;
+        }
+        let internalHeader;
+        try {
+          internalHeader = parseUstarHeader22(headerBlock, strict);
+        } catch (err) {
+          if (strict)
+            throw err;
+          discard(BLOCK_SIZE32);
+          continue;
+        }
+        const metaParser = getMetaParser22(internalHeader.type);
+        if (metaParser) {
+          const paddedSize = internalHeader.size + BLOCK_SIZE_MASK22 & ~BLOCK_SIZE_MASK22;
+          if (available() < BLOCK_SIZE32 + paddedSize) {
+            if (ended && strict)
+              throw truncateErr22;
+            return null;
+          }
+          discard(BLOCK_SIZE32);
+          const overrides = metaParser(pull(paddedSize).subarray(0, internalHeader.size));
+          const target = internalHeader.type === "pax-global-header" ? paxGlobals : nextEntryOverrides;
+          for (const key in overrides)
+            target[key] = overrides[key];
+          continue;
+        }
+        discard(BLOCK_SIZE32);
+        const header = internalHeader;
+        if (internalHeader.prefix)
+          header.name = `${internalHeader.prefix}/${header.name}`;
+        applyOverrides22(header, paxGlobals);
+        applyOverrides22(header, nextEntryOverrides);
+        nextEntryOverrides = {};
+        currentEntry = {
+          header,
+          remaining: header.size,
+          padding: -header.size & BLOCK_SIZE_MASK22
+        };
+        state = STATE_BODY22;
+        return header;
+      }
+    },
+    streamBody(callback) {
+      if (state !== STATE_BODY22 || !currentEntry || currentEntry.remaining === 0)
+        return 0;
+      const bytesToFeed = Math.min(currentEntry.remaining, available());
+      if (bytesToFeed === 0)
+        return 0;
+      const fed = pull(bytesToFeed, callback);
+      currentEntry.remaining -= fed;
+      return fed;
+    },
+    skipPadding() {
+      if (state !== STATE_BODY22 || !currentEntry)
+        return true;
+      if (currentEntry.remaining > 0)
+        throw new Error("Body not fully consumed");
+      if (available() < currentEntry.padding)
+        return false;
+      discard(currentEntry.padding);
+      currentEntry = null;
+      state = STATE_HEADER22;
+      return true;
+    },
+    skipEntry() {
+      if (state !== STATE_BODY22 || !currentEntry)
+        return true;
+      const toDiscard = Math.min(currentEntry.remaining, available());
+      if (toDiscard > 0) {
+        discard(toDiscard);
+        currentEntry.remaining -= toDiscard;
+      }
+      if (currentEntry.remaining > 0)
+        return false;
+      return unpacker.skipPadding();
+    },
+    validateEOF() {
+      if (strict) {
+        if (!eof)
+          throw truncateErr22;
+        if (available() > 0) {
+          if (pull(available()).some((byte) => byte !== 0))
+            throw new Error("Invalid EOF.");
+        }
+      }
+    }
+  };
+  return unpacker;
+}
+function isZeroBlock22(block) {
+  if (block.byteOffset % 8 === 0) {
+    const view = new BigUint64Array(block.buffer, block.byteOffset, block.length / 8);
+    for (let i = 0;i < view.length; i++)
+      if (view[i] !== 0n)
+        return false;
+    return true;
+  }
+  for (let i = 0;i < block.length; i++)
+    if (block[i] !== 0)
+      return false;
+  return true;
+}
+function createTarPacker222() {
+  let streamController;
+  let packer;
+  return {
+    readable: new ReadableStream({ start(controller) {
+      streamController = controller;
+      packer = createTarPacker32(controller.enqueue.bind(controller), controller.error.bind(controller), controller.close.bind(controller));
+    } }),
+    controller: {
+      add(header) {
+        const bodyless = isBodyless22(header);
+        const h = { ...header };
+        if (bodyless)
+          h.size = 0;
+        packer.add(h);
+        if (bodyless)
+          packer.endEntry();
+        return new WritableStream({
+          write(chunk) {
+            packer.write(chunk);
+          },
+          close() {
+            if (!bodyless)
+              packer.endEntry();
+          },
+          abort(reason) {
+            streamController.error(reason);
+          }
+        });
+      },
+      finalize() {
+        packer.finalize();
+      },
+      error(err) {
+        streamController.error(err);
+      }
+    }
+  };
+}
+async function streamToBuffer22(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  let totalLength = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      chunks.push(value);
+      totalLength += value.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  } finally {
+    reader.releaseLock();
+  }
+}
+var drain22 = (stream) => stream.pipeTo(new WritableStream);
+function createTarDecoder22(options = {}) {
+  const unpacker = createUnpacker22(options);
+  let bodyController = null;
+  let pumping = false;
+  const pump = (controller) => {
+    if (pumping)
+      return;
+    pumping = true;
+    try {
+      while (true)
+        if (unpacker.isEntryActive()) {
+          if (bodyController) {
+            if (unpacker.streamBody((c) => (bodyController.enqueue(c), true)) === 0 && !unpacker.isBodyComplete())
+              break;
+          } else if (!unpacker.skipEntry())
+            break;
+          if (unpacker.isBodyComplete()) {
+            try {
+              bodyController?.close();
+            } catch {}
+            bodyController = null;
+            if (!unpacker.skipPadding())
+              break;
+          }
+        } else {
+          const header = unpacker.readHeader();
+          if (header === null || header === undefined)
+            break;
+          controller.enqueue({
+            header,
+            body: new ReadableStream({
+              start(c) {
+                if (header.size === 0)
+                  c.close();
+                else
+                  bodyController = c;
+              },
+              pull: () => pump(controller),
+              cancel() {
+                bodyController = null;
+                pump(controller);
+              }
+            })
+          });
+        }
+    } catch (error) {
+      try {
+        bodyController?.error(error);
+      } catch {}
+      bodyController = null;
+      throw error;
+    } finally {
+      pumping = false;
+    }
+  };
+  return new TransformStream({
+    transform(chunk, controller) {
+      try {
+        unpacker.write(chunk);
+        pump(controller);
+      } catch (error) {
+        try {
+          bodyController?.error(error);
+        } catch {}
+        throw error;
+      }
+    },
+    flush(controller) {
+      try {
+        unpacker.end();
+        pump(controller);
+        unpacker.validateEOF();
+        if (unpacker.isEntryActive() && !unpacker.isBodyComplete())
+          try {
+            bodyController?.close();
+          } catch {}
+      } catch (error) {
+        try {
+          bodyController?.error(error);
+        } catch {}
+        throw error;
+      }
+    }
+  }, undefined, { highWaterMark: 1 });
+}
+async function packTar22(entries) {
+  const { readable, controller } = createTarPacker222();
+  await (async () => {
+    for (const entry of entries) {
+      const entryStream = controller.add(entry.header);
+      const body = "body" in entry ? entry.body : entry.data;
+      if (!body) {
+        await entryStream.close();
+        continue;
+      }
+      if (body instanceof ReadableStream)
+        await body.pipeTo(entryStream);
+      else if (body instanceof Blob)
+        await body.stream().pipeTo(entryStream);
+      else
+        try {
+          const chunk = await normalizeBody22(body);
+          if (chunk.length > 0) {
+            const writer = entryStream.getWriter();
+            await writer.write(chunk);
+            await writer.close();
+          } else
+            await entryStream.close();
+        } catch {
+          throw new TypeError(`Unsupported content type for entry "${entry.header.name}".`);
+        }
+    }
+  })().then(() => controller.finalize()).catch((err) => controller.error(err));
+  return new Uint8Array(await streamToBuffer22(readable));
+}
+async function unpackTar22(archive, options = {}) {
+  const sourceStream = archive instanceof ReadableStream ? archive : new ReadableStream({ start(controller) {
+    controller.enqueue(archive instanceof Uint8Array ? archive : new Uint8Array(archive));
+    controller.close();
+  } });
+  const results = [];
+  const entryStream = sourceStream.pipeThrough(createTarDecoder22(options));
+  for await (const entry of entryStream) {
+    let processedHeader;
+    try {
+      processedHeader = transformHeader22(entry.header, options);
+    } catch (error) {
+      await entry.body.cancel();
+      throw error;
+    }
+    if (processedHeader === null) {
+      await drain22(entry.body);
+      continue;
+    }
+    if (isBodyless22(processedHeader)) {
+      await drain22(entry.body);
+      results.push({ header: processedHeader });
+    } else
+      results.push({
+        header: processedHeader,
+        data: await streamToBuffer22(entry.body)
+      });
+  }
+  return results;
+}
+var gzipAsync32 = promisify32(gzip32);
+var gunzipAsync32 = promisify32(gunzip32);
+
+class RXPImpl22 {
+  _files;
+  _pathsCache = null;
+  _treeCache = null;
+  constructor(files) {
+    this._files = files;
+  }
+  paths() {
+    if (this._pathsCache) {
+      return this._pathsCache;
+    }
+    this._pathsCache = Array.from(this._files.keys()).sort();
+    return this._pathsCache;
+  }
+  tree() {
+    if (this._treeCache) {
+      return this._treeCache;
+    }
+    const root = new Map;
+    for (const path of this._files.keys()) {
+      const parts = path.split("/");
+      let currentLevel = root;
+      for (let i = 0;i < parts.length; i++) {
+        const part = parts[i];
+        const isFile = i === parts.length - 1;
+        if (!currentLevel.has(part)) {
+          const treeNode2 = {
+            node: {
+              name: part,
+              type: isFile ? "file" : "directory",
+              children: isFile ? undefined : []
+            },
+            children: new Map
+          };
+          currentLevel.set(part, treeNode2);
+        }
+        const treeNode = currentLevel.get(part);
+        if (!isFile) {
+          currentLevel = treeNode.children;
+        }
+      }
+    }
+    const convertToPathNodes = (level) => {
+      return Array.from(level.values()).map((treeNode) => {
+        if (treeNode.node.type === "directory" && treeNode.children.size > 0) {
+          treeNode.node.children = convertToPathNodes(treeNode.children);
+        }
+        return treeNode.node;
+      });
+    };
+    this._treeCache = convertToPathNodes(root);
+    return this._treeCache;
+  }
+  async file(path) {
+    const content = this._files.get(path);
+    if (!content) {
+      throw new ContentError22(`file not found: ${path}`);
+    }
+    return content;
+  }
+  async files() {
+    return new Map(this._files);
+  }
+  async pack() {
+    const filesRecord = {};
+    for (const [path, content] of this._files) {
+      filesRecord[path] = content;
+    }
+    return createRXA22(filesRecord);
+  }
+}
+
+class RXAImpl22 {
+  _buffer;
+  _rxpCache = null;
+  constructor(buffer) {
+    this._buffer = buffer;
+  }
+  get stream() {
+    const buffer = this._buffer;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(buffer));
+        controller.close();
+      }
+    });
+  }
+  async buffer() {
+    return this._buffer;
+  }
+  async extract() {
+    if (this._rxpCache) {
+      return this._rxpCache;
+    }
+    const tarBuffer = await gunzipAsync32(this._buffer);
+    const entries = await unpackTar22(tarBuffer);
+    const filesMap = new Map;
+    for (const entry of entries) {
+      if ((entry.header.type === "file" || entry.header.type === undefined) && entry.data) {
+        filesMap.set(entry.header.name, Buffer.from(entry.data));
+      }
+    }
+    this._rxpCache = new RXPImpl22(filesMap);
+    return this._rxpCache;
+  }
+}
+function isBufferInput22(input) {
+  return "buffer" in input && Buffer.isBuffer(input.buffer);
+}
+async function createRXA22(input) {
+  if (isBufferInput22(input)) {
+    return new RXAImpl22(input.buffer);
+  }
+  const entries = Object.entries(input).map(([name, content]) => {
+    const body = typeof content === "string" ? content : content instanceof Uint8Array ? content : new Uint8Array(content);
+    const size = typeof content === "string" ? Buffer.byteLength(content) : content.length;
+    return {
+      header: { name, size, type: "file" },
+      body
+    };
+  });
+  const tarBuffer = await packTar22(entries);
+  const gzipBuffer = await gzipAsync32(Buffer.from(tarBuffer));
+  return new RXAImpl22(gzipBuffer);
+}
+
+class FolderLoader {
+  async canLoad(source) {
+    try {
+      const stats = await stat2(source);
+      if (!stats.isDirectory()) {
+        return false;
+      }
+      const manifestPath = join2(source, "resource.json");
+      const manifestStats = await stat2(manifestPath);
+      return manifestStats.isFile();
+    } catch {
+      return false;
+    }
+  }
+  async load(folderPath) {
+    const manifestPath = join2(folderPath, "resource.json");
+    let manifestJson;
+    try {
+      manifestJson = await readFile2(manifestPath, "utf-8");
+    } catch (error) {
+      throw new ResourceXError32(`Failed to read resource.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let manifestData;
+    try {
+      manifestData = JSON.parse(manifestJson);
+    } catch (error) {
+      throw new ResourceXError32(`Invalid JSON in resource.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!manifestData.name) {
+      throw new ResourceXError32("Invalid resource.json: missing required field 'name'");
+    }
+    if (!manifestData.type) {
+      throw new ResourceXError32("Invalid resource.json: missing required field 'type'");
+    }
+    if (!manifestData.version) {
+      throw new ResourceXError32("Invalid resource.json: missing required field 'version'");
+    }
+    const manifest = createRXM22({
+      domain: manifestData.domain ?? "localhost",
+      path: manifestData.path,
+      name: manifestData.name,
+      type: manifestData.type,
+      version: manifestData.version
+    });
+    const files = await this.readFolderFiles(folderPath);
+    if (Object.keys(files).length === 0) {
+      throw new ResourceXError32("No content files found in resource folder");
+    }
+    const archive = await createRXA22(files);
+    const locator = parseRXL32(manifest.toLocator());
+    return {
+      locator,
+      manifest,
+      archive
+    };
+  }
+  async readFolderFiles(folderPath, basePath = folderPath) {
+    const files = {};
+    const entries = await readdir2(folderPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join2(folderPath, entry.name);
+      const relativePath = relative(basePath, fullPath);
+      if (relativePath === "resource.json") {
+        continue;
+      }
+      if (entry.isFile()) {
+        files[relativePath] = await readFile2(fullPath);
+      } else if (entry.isDirectory()) {
+        const subFiles = await this.readFolderFiles(fullPath, basePath);
+        Object.assign(files, subFiles);
+      }
+    }
+    return files;
+  }
+}
+async function loadResource(source, config) {
+  const loader = config?.loader ?? new FolderLoader;
+  const canLoad = await loader.canLoad(source);
+  if (!canLoad) {
+    throw new ResourceXError32(`Cannot load resource from: ${source}`);
+  }
+  return loader.load(source);
+}
+var DEFAULT_PATH = `${homedir()}/.resourcex`;
+
+class LocalRegistry {
+  basePath;
+  typeHandler;
+  arp;
+  constructor(config) {
+    this.basePath = config?.path ?? DEFAULT_PATH;
+    this.typeHandler = TypeHandlerChain2.create();
+    this.arp = createARP();
+    if (config?.types) {
+      for (const type of config.types) {
+        this.typeHandler.register(type);
+      }
+    }
+  }
+  supportType(type) {
+    this.typeHandler.register(type);
+  }
+  toArpUrl(filePath) {
+    return `arp:binary:file://${filePath}`;
+  }
+  buildPath(locator, area) {
+    const rxl = typeof locator === "string" ? parseRXL3(locator) : locator;
+    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
+    const version = rxl.version ?? "latest";
+    if (area === "local") {
+      return join3(this.basePath, "local", resourceName, version);
+    } else {
+      const domain = rxl.domain ?? "localhost";
+      let path = join3(this.basePath, "cache", domain);
+      if (rxl.path) {
+        path = join3(path, rxl.path);
+      }
+      return join3(path, resourceName, version);
+    }
+  }
+  isLocalOnlyLocator(locator) {
+    const rxl = typeof locator === "string" ? parseRXL3(locator) : locator;
+    return !rxl.domain || rxl.domain === "localhost";
+  }
+  async existsAt(resourcePath) {
+    const manifestPath = join3(resourcePath, "manifest.json");
+    const arl = this.arp.parse(this.toArpUrl(manifestPath));
+    return arl.exists();
+  }
+  async findArea(locator) {
+    const localPath = this.buildPath(locator, "local");
+    if (await this.existsAt(localPath)) {
+      return "local";
+    }
+    const cachePath = this.buildPath(locator, "cache");
+    if (await this.existsAt(cachePath)) {
+      return "cache";
+    }
+    return null;
+  }
+  async isSymlink(path) {
+    try {
+      const stats = await lstat(path);
+      return stats.isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }
+  async loadFrom(resourcePath) {
+    if (await this.isSymlink(resourcePath)) {
+      const targetPath = await readlink(resourcePath);
+      return loadResource(targetPath);
+    }
+    const manifestPath = join3(resourcePath, "manifest.json");
+    const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
+    const manifestResource = await manifestArl.resolve();
+    const manifestContent = manifestResource.content.toString("utf-8");
+    const manifestData = JSON.parse(manifestContent);
+    const manifest = createRXM2(manifestData);
+    const contentPath = join3(resourcePath, "archive.tar.gz");
+    const contentArl = this.arp.parse(this.toArpUrl(contentPath));
+    const contentResource = await contentArl.resolve();
+    const data = contentResource.content;
+    return this.typeHandler.deserialize(data, manifest);
+  }
+  async link(path) {
+    const rxr = await loadResource(path);
+    const locator = rxr.manifest.toLocator();
+    const resourcePath = this.buildPath(locator, "local");
+    try {
+      const arl = this.arp.parse(this.toArpUrl(resourcePath));
+      if (await arl.exists()) {
+        await arl.delete();
+      }
+    } catch {}
+    const parentPath = join3(resourcePath, "..");
+    const parentArl = this.arp.parse(this.toArpUrl(parentPath));
+    await parentArl.mkdir();
+    const absolutePath = resolvePath(path);
+    await symlink(absolutePath, resourcePath);
+  }
+  async add(source) {
+    const resource = typeof source === "string" ? await loadResource(source) : source;
+    const locator = resource.manifest.toLocator();
+    const resourcePath = this.buildPath(locator, "local");
+    if (await this.isSymlink(resourcePath)) {
+      const arl = this.arp.parse(this.toArpUrl(resourcePath));
+      await arl.delete();
+    }
+    const dirArl = this.arp.parse(this.toArpUrl(resourcePath));
+    await dirArl.mkdir();
+    const manifestPath = join3(resourcePath, "manifest.json");
+    const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
+    const manifestContent = Buffer.from(JSON.stringify(resource.manifest.toJSON(), null, 2), "utf-8");
+    await manifestArl.deposit(manifestContent);
+    const contentPath = join3(resourcePath, "archive.tar.gz");
+    const contentArl = this.arp.parse(this.toArpUrl(contentPath));
+    const serialized = await this.typeHandler.serialize(resource);
+    await contentArl.deposit(serialized);
+  }
+  async pull(_locator, _options) {
+    throw new RegistryError("Pull not implemented yet - see issue #018");
+  }
+  async publish(_source, _options) {
+    throw new RegistryError("Publish not implemented yet - see issue #018");
+  }
+  async get(locator) {
+    const area = await this.findArea(locator);
+    if (!area) {
+      throw new RegistryError(`Resource not found: ${locator}`);
+    }
+    const resourcePath = this.buildPath(locator, area);
+    return this.loadFrom(resourcePath);
+  }
+  async resolve(locator) {
+    const rxr = await this.get(locator);
+    return this.typeHandler.resolve(rxr);
   }
   async exists(locator) {
     const area = await this.findArea(locator);
@@ -27823,7 +29389,7 @@ class LocalRegistry {
   async search(options) {
     const { query, limit, offset = 0 } = options ?? {};
     const locators = [];
-    const localDir = join2(this.basePath, "local");
+    const localDir = join3(this.basePath, "local");
     try {
       const localArl = this.arp.parse(this.toArpUrl(localDir));
       const localEntries = await localArl.list({ recursive: true, pattern: "*.json" });
@@ -27835,7 +29401,7 @@ class LocalRegistry {
           locators.push(rxl);
       }
     } catch {}
-    const cacheDir = join2(this.basePath, "cache");
+    const cacheDir = join3(this.basePath, "cache");
     try {
       const cacheArl = this.arp.parse(this.toArpUrl(cacheDir));
       const cacheEntries = await cacheArl.list({ recursive: true, pattern: "*.json" });
@@ -27921,6 +29487,12 @@ class LocalRegistry {
 }
 
 class RemoteRegistry {
+  static canHandle(url) {
+    return url.startsWith("https://") || url.startsWith("http://");
+  }
+  static create(config) {
+    return new RemoteRegistry({ endpoint: config.url });
+  }
   endpoint;
   typeHandler;
   constructor(config) {
@@ -27930,15 +29502,18 @@ class RemoteRegistry {
   supportType(type) {
     this.typeHandler.register(type);
   }
+  async link(_path) {
+    throw new RegistryError("Cannot link to remote registry - use local registry for linking");
+  }
+  async add(_source) {
+    throw new RegistryError("Cannot add to remote registry - use local registry for adding");
+  }
   async pull(_locator, _options) {
     throw new RegistryError("Cannot pull to remote registry - use local registry for pulling");
   }
-  async publish(_resource, _options) {
+  async publish(_source, _options) {
     throw new RegistryError("Remote registry publish not implemented yet");
   }
-  async link(_resource) {
-    throw new RegistryError("Cannot link to remote registry - use local registry for linking");
-  }
   async get(locator) {
     const manifestUrl = `${this.endpoint}/resource?locator=${encodeURIComponent(locator)}`;
     const manifestResponse = await fetch(manifestUrl);
@@ -28013,6 +29588,18 @@ async function discoverRegistry(domain) {
     throw new RegistryError(`Failed to discover registry for ${domain}: ${error.message}`);
   }
 }
+function isUrlConfig(config) {
+  return config !== undefined && "url" in config && !("type" in config) && !("endpoint" in config);
+}
+function isRemoteConfig(config) {
+  return config !== undefined && "endpoint" in config;
+}
+function isGitConfig(config) {
+  return config !== undefined && "type" in config && config.type === "git";
+}
+function isGitHubConfig(config) {
+  return config !== undefined && "type" in config && config.type === "github";
+}
 var import_isomorphic_git = __toESM(require_isomorphic_git(), 1);
 var import_simple_get = __toESM(require_simple_get(), 1);
 function fromValue(value) {
@@ -28167,8 +29754,71 @@ async function request({
     });
   });
 }
-var index = { request };
-var node_default = index;
+var index = { request };
+var node_default = index;
+
+class RegistryMiddleware {
+  inner;
+  constructor(inner) {
+    this.inner = inner;
+  }
+  supportType(type) {
+    this.inner.supportType(type);
+  }
+  link(path) {
+    return this.inner.link(path);
+  }
+  add(source) {
+    return this.inner.add(source);
+  }
+  pull(locator, options) {
+    return this.inner.pull(locator, options);
+  }
+  publish(source, options) {
+    return this.inner.publish(source, options);
+  }
+  get(locator) {
+    return this.inner.get(locator);
+  }
+  resolve(locator) {
+    return this.inner.resolve(locator);
+  }
+  exists(locator) {
+    return this.inner.exists(locator);
+  }
+  delete(locator) {
+    return this.inner.delete(locator);
+  }
+  search(options) {
+    return this.inner.search(options);
+  }
+}
+
+class DomainValidation extends RegistryMiddleware {
+  trustedDomain;
+  constructor(inner, trustedDomain) {
+    super(inner);
+    this.trustedDomain = trustedDomain;
+  }
+  validateDomain(rxr) {
+    if (rxr.manifest.domain !== this.trustedDomain) {
+      throw new RegistryError(`Untrusted domain: resource claims "${rxr.manifest.domain}" but registry only trusts "${this.trustedDomain}"`);
+    }
+  }
+  async get(locator) {
+    const rxr = await this.inner.get(locator);
+    this.validateDomain(rxr);
+    return rxr;
+  }
+  async resolve(locator) {
+    const rxr = await this.inner.get(locator);
+    this.validateDomain(rxr);
+    return this.inner.resolve(locator);
+  }
+}
+function withDomainValidation(registry, trustedDomain) {
+  return new DomainValidation(registry, trustedDomain);
+}
 var DEFAULT_GIT_CACHE = `${homedir2()}/.resourcex/.git-cache`;
 var MAX_RETRIES = 2;
 function isLocalPath(url) {
@@ -28176,6 +29826,19 @@ function isLocalPath(url) {
 }
 
 class GitRegistry {
+  static canHandle(url) {
+    return url.startsWith("git@") || url.endsWith(".git");
+  }
+  static create(config) {
+    const registry = new GitRegistry({
+      type: "git",
+      url: config.url,
+      ref: config.ref,
+      basePath: config.basePath,
+      domain: config.domain
+    });
+    return config.domain ? withDomainValidation(registry, config.domain) : registry;
+  }
   url;
   ref;
   basePath;
@@ -28201,7 +29864,7 @@ class GitRegistry {
       normalized = normalized.slice(0, -4);
     }
     const dirName = normalized.replace(/\//g, "-");
-    return join3(DEFAULT_GIT_CACHE, dirName);
+    return join4(DEFAULT_GIT_CACHE, dirName);
   }
   supportType(type) {
     this.typeHandler.register(type);
@@ -28210,7 +29873,7 @@ class GitRegistry {
     return `arp:binary:file://${filePath}`;
   }
   async ensureCloned() {
-    const gitDir = join3(this.cacheDir, ".git");
+    const gitDir = join4(this.cacheDir, ".git");
     const gitArl = this.arp.parse(this.toArpUrl(gitDir));
     if (this.isLocal) {
       if (!await gitArl.exists()) {
@@ -28289,17 +29952,17 @@ class GitRegistry {
     const rxl = parseRXL3(locator);
     const domain = rxl.domain ?? "localhost";
     const version = rxl.version ?? "latest";
-    let path = join3(this.cacheDir, this.basePath, domain);
+    let path = join4(this.cacheDir, this.basePath, domain);
     if (rxl.path) {
-      path = join3(path, rxl.path);
+      path = join4(path, rxl.path);
     }
     const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    return join3(path, resourceName, version);
+    return join4(path, resourceName, version);
   }
   async get(locator) {
     await this.ensureCloned();
     const resourcePath = this.buildResourcePath(locator);
-    const manifestPath = join3(resourcePath, "manifest.json");
+    const manifestPath = join4(resourcePath, "manifest.json");
     const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
     if (!await manifestArl.exists()) {
       throw new RegistryError(`Resource not found: ${locator}`);
@@ -28308,7 +29971,7 @@ class GitRegistry {
     const manifestContent = manifestResource.content.toString("utf-8");
     const manifestData = JSON.parse(manifestContent);
     const manifest = createRXM2(manifestData);
-    const contentPath = join3(resourcePath, "content.tar.gz");
+    const contentPath = join4(resourcePath, "archive.tar.gz");
     const contentArl = this.arp.parse(this.toArpUrl(contentPath));
     const contentResource = await contentArl.resolve();
     const data = contentResource.content;
@@ -28322,7 +29985,7 @@ class GitRegistry {
     try {
       await this.ensureCloned();
       const resourcePath = this.buildResourcePath(locator);
-      const manifestPath = join3(resourcePath, "manifest.json");
+      const manifestPath = join4(resourcePath, "manifest.json");
       const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
       return await manifestArl.exists();
     } catch {
@@ -28333,7 +29996,7 @@ class GitRegistry {
     await this.ensureCloned();
     const { query, limit, offset = 0 } = options ?? {};
     const locators = [];
-    const baseDir = join3(this.cacheDir, this.basePath);
+    const baseDir = join4(this.cacheDir, this.basePath);
     try {
       const baseArl = this.arp.parse(this.toArpUrl(baseDir));
       const entries = await baseArl.list({ recursive: true, pattern: "*.json" });
@@ -28393,107 +30056,337 @@ class GitRegistry {
       return null;
     }
   }
+  async link(_path) {
+    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.link()");
+  }
+  async add(_source) {
+    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.add()");
+  }
   async pull(_locator, _options) {
     throw new RegistryError("GitRegistry is read-only - use LocalRegistry.pull()");
   }
-  async publish(_resource, _options) {
+  async publish(_source, _options) {
     throw new RegistryError("GitRegistry is read-only - use LocalRegistry.publish()");
   }
-  async link(_resource) {
-    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.link()");
-  }
   async delete(_locator) {
     throw new RegistryError("GitRegistry is read-only - use LocalRegistry.delete()");
   }
 }
+var DEFAULT_GITHUB_CACHE = `${homedir3()}/.resourcex/.github-cache`;
+function parseGitHubUrl(url) {
+  if (!url.startsWith("https://github.com/")) {
+    throw new RegistryError(`Invalid GitHub URL: ${url}. Expected format: https://github.com/owner/repo`);
+  }
+  const path = url.slice("https://github.com/".length);
+  const parts = path.split("/");
+  if (parts.length < 2) {
+    throw new RegistryError(`Invalid GitHub URL: ${url}. Expected format: https://github.com/owner/repo`);
+  }
+  const owner = parts[0];
+  const repo = parts[1];
+  let branch = "main";
+  if (parts.length >= 4 && parts[2] === "tree") {
+    branch = parts[3];
+  }
+  return { owner, repo, branch };
+}
+function isGitHubUrl(url) {
+  return url.startsWith("https://github.com/");
+}
 
-class RegistryMiddleware {
-  inner;
-  constructor(inner) {
-    this.inner = inner;
+class GitHubRegistry {
+  static canHandle(url) {
+    return isGitHubUrl(url);
+  }
+  static create(config) {
+    const registry = new GitHubRegistry({
+      url: config.url,
+      ref: config.ref,
+      basePath: config.basePath
+    });
+    return config.domain ? withDomainValidation(registry, config.domain) : registry;
+  }
+  url;
+  owner;
+  repo;
+  ref;
+  basePath;
+  cacheDir;
+  typeHandler;
+  arp;
+  tarballDownloaded = false;
+  constructor(config) {
+    this.url = config.url;
+    const parsed = parseGitHubUrl(config.url);
+    this.owner = parsed.owner;
+    this.repo = parsed.repo;
+    this.ref = config.ref ?? parsed.branch;
+    this.basePath = config.basePath ?? ".resourcex";
+    this.typeHandler = TypeHandlerChain2.create();
+    this.arp = createARP();
+    this.cacheDir = this.buildCacheDir();
+  }
+  buildCacheDir() {
+    const dirName = `github.com-${this.owner}-${this.repo}`;
+    return join5(DEFAULT_GITHUB_CACHE, dirName);
   }
   supportType(type) {
-    this.inner.supportType(type);
+    this.typeHandler.register(type);
   }
-  pull(locator, options) {
-    return this.inner.pull(locator, options);
+  toArpUrl(filePath) {
+    return `arp:binary:file://${filePath}`;
   }
-  publish(resource, options) {
-    return this.inner.publish(resource, options);
+  getTarballUrl() {
+    return `https://github.com/${this.owner}/${this.repo}/archive/refs/heads/${this.ref}.tar.gz`;
   }
-  link(resource) {
-    return this.inner.link(resource);
+  async ensureDownloaded() {
+    if (this.tarballDownloaded) {
+      return;
+    }
+    const tarballUrl = this.getTarballUrl();
+    const response = await fetch(tarballUrl, {
+      headers: {
+        "User-Agent": "ResourceX/1.0"
+      }
+    });
+    if (!response.ok) {
+      throw new RegistryError(`Failed to download tarball from ${tarballUrl}: ${response.status} ${response.statusText}`);
+    }
+    const tarballBuffer = Buffer.from(await response.arrayBuffer());
+    await this.extractTarball(tarballBuffer);
+    this.tarballDownloaded = true;
+  }
+  async extractTarball(tarballBuffer) {
+    const tarBuffer = gunzipSync(tarballBuffer);
+    const files = this.parseTar(tarBuffer);
+    const cacheArl = this.arp.parse(this.toArpUrl(this.cacheDir));
+    await cacheArl.mkdir();
+    for (const [path, content] of files) {
+      const parts = path.split("/");
+      if (parts.length < 2)
+        continue;
+      const relativePath = parts.slice(1).join("/");
+      if (!relativePath)
+        continue;
+      const fullPath = join5(this.cacheDir, relativePath);
+      const parentDir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+      if (parentDir) {
+        const parentArl = this.arp.parse(this.toArpUrl(parentDir));
+        await parentArl.mkdir();
+      }
+      const fileArl = this.arp.parse(this.toArpUrl(fullPath));
+      await fileArl.deposit(content);
+    }
   }
-  get(locator) {
-    return this.inner.get(locator);
+  parseTar(tarBuffer) {
+    const files = new Map;
+    let offset = 0;
+    while (offset < tarBuffer.length) {
+      const header = tarBuffer.subarray(offset, offset + 512);
+      if (header[0] === 0) {
+        break;
+      }
+      let filename = "";
+      for (let i = 0;i < 100 && header[i] !== 0; i++) {
+        filename += String.fromCharCode(header[i]);
+      }
+      let prefix = "";
+      for (let i = 345;i < 500 && header[i] !== 0; i++) {
+        prefix += String.fromCharCode(header[i]);
+      }
+      if (prefix) {
+        filename = prefix + "/" + filename;
+      }
+      let sizeStr = "";
+      for (let i = 124;i < 136 && header[i] !== 0 && header[i] !== 32; i++) {
+        sizeStr += String.fromCharCode(header[i]);
+      }
+      const size = parseInt(sizeStr, 8) || 0;
+      const typeFlag = header[156];
+      offset += 512;
+      if (typeFlag === 48 || typeFlag === 0) {
+        if (size > 0) {
+          const content = tarBuffer.subarray(offset, offset + size);
+          files.set(filename, Buffer.from(content));
+        }
+      }
+      offset += Math.ceil(size / 512) * 512;
+    }
+    return files;
   }
-  resolve(locator) {
-    return this.inner.resolve(locator);
+  buildResourcePath(locator) {
+    const rxl = parseRXL3(locator);
+    const domain = rxl.domain ?? "localhost";
+    const version = rxl.version ?? "latest";
+    let path = join5(this.cacheDir, this.basePath, domain);
+    if (rxl.path) {
+      path = join5(path, rxl.path);
+    }
+    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
+    return join5(path, resourceName, version);
   }
-  exists(locator) {
-    return this.inner.exists(locator);
+  async get(locator) {
+    await this.ensureDownloaded();
+    const resourcePath = this.buildResourcePath(locator);
+    const manifestPath = join5(resourcePath, "manifest.json");
+    const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
+    if (!await manifestArl.exists()) {
+      throw new RegistryError(`Resource not found: ${locator}`);
+    }
+    const manifestResource = await manifestArl.resolve();
+    const manifestContent = manifestResource.content.toString("utf-8");
+    const manifestData = JSON.parse(manifestContent);
+    const manifest = createRXM2(manifestData);
+    const contentPath = join5(resourcePath, "archive.tar.gz");
+    const contentArl = this.arp.parse(this.toArpUrl(contentPath));
+    const contentResource = await contentArl.resolve();
+    const data = contentResource.content;
+    return this.typeHandler.deserialize(data, manifest);
   }
-  delete(locator) {
-    return this.inner.delete(locator);
+  async resolve(locator) {
+    const rxr = await this.get(locator);
+    return this.typeHandler.resolve(rxr);
   }
-  search(options) {
-    return this.inner.search(options);
+  async exists(locator) {
+    try {
+      await this.ensureDownloaded();
+      const resourcePath = this.buildResourcePath(locator);
+      const manifestPath = join5(resourcePath, "manifest.json");
+      const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
+      return await manifestArl.exists();
+    } catch {
+      return false;
+    }
   }
-}
-
-class DomainValidation extends RegistryMiddleware {
-  trustedDomain;
-  constructor(inner, trustedDomain) {
-    super(inner);
-    this.trustedDomain = trustedDomain;
+  async search(options) {
+    await this.ensureDownloaded();
+    const { query, limit, offset = 0 } = options ?? {};
+    const locators = [];
+    const baseDir = join5(this.cacheDir, this.basePath);
+    try {
+      const baseArl = this.arp.parse(this.toArpUrl(baseDir));
+      const entries = await baseArl.list({ recursive: true, pattern: "*.json" });
+      for (const entry of entries) {
+        if (!entry.endsWith("manifest.json"))
+          continue;
+        const rxl = this.parseEntryToRXL(entry);
+        if (rxl)
+          locators.push(rxl);
+      }
+    } catch {
+      return [];
+    }
+    let filtered = locators;
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      filtered = locators.filter((rxl) => {
+        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
+        return searchText.includes(lowerQuery);
+      });
+    }
+    let result = filtered.slice(offset);
+    if (limit !== undefined) {
+      result = result.slice(0, limit);
+    }
+    return result;
   }
-  validateDomain(rxr) {
-    if (rxr.manifest.domain !== this.trustedDomain) {
-      throw new RegistryError(`Untrusted domain: resource claims "${rxr.manifest.domain}" but registry only trusts "${this.trustedDomain}"`);
+  parseEntryToRXL(entry) {
+    const dirPath = entry.replace(/[/\\]manifest\.json$/, "");
+    const parts = dirPath.split(/[/\\]/);
+    if (parts.length < 3)
+      return null;
+    const version = parts.pop();
+    const nameTypePart = parts.pop();
+    const domain = parts.shift();
+    const path = parts.length > 0 ? parts.join("/") : undefined;
+    const dotIndex = nameTypePart.lastIndexOf(".");
+    let name;
+    let type;
+    if (dotIndex !== -1) {
+      name = nameTypePart.substring(0, dotIndex);
+      type = nameTypePart.substring(dotIndex + 1);
+    } else {
+      name = nameTypePart;
+      type = undefined;
+    }
+    let locatorStr = domain;
+    if (path)
+      locatorStr += `/${path}`;
+    locatorStr += `/${name}`;
+    if (type)
+      locatorStr += `.${type}`;
+    locatorStr += `@${version}`;
+    try {
+      return parseRXL3(locatorStr);
+    } catch {
+      return null;
     }
   }
-  async get(locator) {
-    const rxr = await this.inner.get(locator);
-    this.validateDomain(rxr);
-    return rxr;
+  async link(_path) {
+    throw new RegistryError("GitHubRegistry is read-only - use LocalRegistry.link()");
   }
-  async resolve(locator) {
-    const rxr = await this.inner.get(locator);
-    this.validateDomain(rxr);
-    return this.inner.resolve(locator);
+  async add(_source) {
+    throw new RegistryError("GitHubRegistry is read-only - use LocalRegistry.add()");
+  }
+  async pull(_locator, _options) {
+    throw new RegistryError("GitHubRegistry is read-only - use LocalRegistry.pull()");
+  }
+  async publish(_source, _options) {
+    throw new RegistryError("GitHubRegistry is read-only - use LocalRegistry.publish()");
+  }
+  async delete(_locator) {
+    throw new RegistryError("GitHubRegistry is read-only - use LocalRegistry.delete()");
   }
 }
-function withDomainValidation(registry, trustedDomain) {
-  return new DomainValidation(registry, trustedDomain);
-}
-function isRemoteGitUrl(url) {
+var URL_HANDLERS = [
+  GitHubRegistry,
+  GitRegistry,
+  RemoteRegistry
+];
+function isRemoteUrl(url) {
   return url.startsWith("git@") || url.startsWith("https://") || url.startsWith("http://");
 }
 function createRegistry(config) {
   if (isRemoteConfig(config)) {
     return new RemoteRegistry(config);
   }
+  if (isGitHubConfig(config)) {
+    const registry = new GitHubRegistry(config);
+    return config.domain ? withDomainValidation(registry, config.domain) : registry;
+  }
   if (isGitConfig(config)) {
-    if (isRemoteGitUrl(config.url) && !config.domain) {
+    if (isRemoteUrl(config.url) && !config.domain) {
       throw new RegistryError(`Remote git registry requires a trusted domain.
 
-` + `Either:
-` + `1. Use discoverRegistry("your-domain.com") to auto-bind domain
-` + `2. Explicitly set domain: createRegistry({ type: "git", url: "...", domain: "your-domain.com" })
-
-` + `This ensures resources from untrusted sources cannot impersonate your domain.`);
-    }
-    const gitRegistry = new GitRegistry(config);
-    if (config.domain) {
-      return withDomainValidation(gitRegistry, config.domain);
+` + `Use discoverRegistry() or explicitly set domain:
+` + `createRegistry({ type: "git", url: "...", domain: "your-domain.com" })`);
     }
-    return gitRegistry;
+    const registry = new GitRegistry(config);
+    return config.domain ? withDomainValidation(registry, config.domain) : registry;
+  }
+  if (isUrlConfig(config)) {
+    return createFromUrl(config);
   }
   return new LocalRegistry(config);
 }
+function createFromUrl(config) {
+  const { url, domain } = config;
+  if (isRemoteUrl(url) && !domain) {
+    throw new RegistryError(`Remote registry URL requires a trusted domain.
+
+` + `Use discoverRegistry() or explicitly set domain:
+` + `createRegistry({ url: "...", domain: "your-domain.com" })`);
+  }
+  for (const Handler of URL_HANDLERS) {
+    if (Handler.canHandle(url)) {
+      return Handler.create(config);
+    }
+  }
+  throw new RegistryError(`No handler found for URL: ${url}`);
+}
 // ../loader/dist/index.js
-import { join as join4, relative } from "node:path";
-import { stat as stat2, readFile as readFile2, readdir as readdir2 } from "node:fs/promises";
+import { join as join6, relative as relative2 } from "node:path";
+import { stat as stat3, readFile as readFile3, readdir as readdir3 } from "node:fs/promises";
 import { gzip as gzip4, gunzip as gunzip4 } from "node:zlib";
 import { promisify as promisify4 } from "node:util";
 
@@ -29620,9 +31513,81 @@ async function unpackTar4(archive, options = {}) {
 var gzipAsync4 = promisify4(gzip4);
 var gunzipAsync4 = promisify4(gunzip4);
 
-class RXCImpl4 {
+class RXPImpl4 {
+  _files;
+  _pathsCache = null;
+  _treeCache = null;
+  constructor(files) {
+    this._files = files;
+  }
+  paths() {
+    if (this._pathsCache) {
+      return this._pathsCache;
+    }
+    this._pathsCache = Array.from(this._files.keys()).sort();
+    return this._pathsCache;
+  }
+  tree() {
+    if (this._treeCache) {
+      return this._treeCache;
+    }
+    const root = new Map;
+    for (const path of this._files.keys()) {
+      const parts = path.split("/");
+      let currentLevel = root;
+      for (let i = 0;i < parts.length; i++) {
+        const part = parts[i];
+        const isFile = i === parts.length - 1;
+        if (!currentLevel.has(part)) {
+          const treeNode2 = {
+            node: {
+              name: part,
+              type: isFile ? "file" : "directory",
+              children: isFile ? undefined : []
+            },
+            children: new Map
+          };
+          currentLevel.set(part, treeNode2);
+        }
+        const treeNode = currentLevel.get(part);
+        if (!isFile) {
+          currentLevel = treeNode.children;
+        }
+      }
+    }
+    const convertToPathNodes = (level) => {
+      return Array.from(level.values()).map((treeNode) => {
+        if (treeNode.node.type === "directory" && treeNode.children.size > 0) {
+          treeNode.node.children = convertToPathNodes(treeNode.children);
+        }
+        return treeNode.node;
+      });
+    };
+    this._treeCache = convertToPathNodes(root);
+    return this._treeCache;
+  }
+  async file(path) {
+    const content = this._files.get(path);
+    if (!content) {
+      throw new ContentError4(`file not found: ${path}`);
+    }
+    return content;
+  }
+  async files() {
+    return new Map(this._files);
+  }
+  async pack() {
+    const filesRecord = {};
+    for (const [path, content] of this._files) {
+      filesRecord[path] = content;
+    }
+    return createRXA4(filesRecord);
+  }
+}
+
+class RXAImpl4 {
   _buffer;
-  _filesCache = null;
+  _rxpCache = null;
   constructor(buffer) {
     this._buffer = buffer;
   }
@@ -29638,17 +31603,9 @@ class RXCImpl4 {
   async buffer() {
     return this._buffer;
   }
-  async file(path) {
-    const filesMap = await this.files();
-    const content = filesMap.get(path);
-    if (!content) {
-      throw new ContentError4(`file not found: ${path}`);
-    }
-    return content;
-  }
-  async files() {
-    if (this._filesCache) {
-      return this._filesCache;
+  async extract() {
+    if (this._rxpCache) {
+      return this._rxpCache;
     }
     const tarBuffer = await gunzipAsync4(this._buffer);
     const entries = await unpackTar4(tarBuffer);
@@ -29658,16 +31615,16 @@ class RXCImpl4 {
         filesMap.set(entry.header.name, Buffer.from(entry.data));
       }
     }
-    this._filesCache = filesMap;
-    return filesMap;
+    this._rxpCache = new RXPImpl4(filesMap);
+    return this._rxpCache;
   }
 }
-function isArchiveInput4(input) {
-  return "archive" in input && Buffer.isBuffer(input.archive);
+function isBufferInput4(input) {
+  return "buffer" in input && Buffer.isBuffer(input.buffer);
 }
-async function createRXC4(input) {
-  if (isArchiveInput4(input)) {
-    return new RXCImpl4(input.archive);
+async function createRXA4(input) {
+  if (isBufferInput4(input)) {
+    return new RXAImpl4(input.buffer);
   }
   const entries = Object.entries(input).map(([name, content]) => {
     const body = typeof content === "string" ? content : content instanceof Uint8Array ? content : new Uint8Array(content);
@@ -29679,28 +31636,28 @@ async function createRXC4(input) {
   });
   const tarBuffer = await packTar4(entries);
   const gzipBuffer = await gzipAsync4(Buffer.from(tarBuffer));
-  return new RXCImpl4(gzipBuffer);
+  return new RXAImpl4(gzipBuffer);
 }
 
-class FolderLoader {
+class FolderLoader2 {
   async canLoad(source) {
     try {
-      const stats = await stat2(source);
+      const stats = await stat3(source);
       if (!stats.isDirectory()) {
         return false;
       }
-      const manifestPath = join4(source, "resource.json");
-      const manifestStats = await stat2(manifestPath);
+      const manifestPath = join6(source, "resource.json");
+      const manifestStats = await stat3(manifestPath);
       return manifestStats.isFile();
     } catch {
       return false;
     }
   }
   async load(folderPath) {
-    const manifestPath = join4(folderPath, "resource.json");
+    const manifestPath = join6(folderPath, "resource.json");
     let manifestJson;
     try {
-      manifestJson = await readFile2(manifestPath, "utf-8");
+      manifestJson = await readFile3(manifestPath, "utf-8");
     } catch (error) {
       throw new ResourceXError4(`Failed to read resource.json: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -29730,25 +31687,25 @@ class FolderLoader {
     if (Object.keys(files).length === 0) {
       throw new ResourceXError4("No content files found in resource folder");
     }
-    const content = await createRXC4(files);
+    const archive = await createRXA4(files);
     const locator = parseRXL4(manifest.toLocator());
     return {
       locator,
       manifest,
-      content
+      archive
     };
   }
   async readFolderFiles(folderPath, basePath = folderPath) {
     const files = {};
-    const entries = await readdir2(folderPath, { withFileTypes: true });
+    const entries = await readdir3(folderPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join4(folderPath, entry.name);
-      const relativePath = relative(basePath, fullPath);
+      const fullPath = join6(folderPath, entry.name);
+      const relativePath = relative2(basePath, fullPath);
       if (relativePath === "resource.json") {
         continue;
       }
       if (entry.isFile()) {
-        files[relativePath] = await readFile2(fullPath);
+        files[relativePath] = await readFile3(fullPath);
       } else if (entry.isDirectory()) {
         const subFiles = await this.readFolderFiles(fullPath, basePath);
         Object.assign(files, subFiles);
@@ -29757,8 +31714,8 @@ class FolderLoader {
     return files;
   }
 }
-async function loadResource(source, config) {
-  const loader = config?.loader ?? new FolderLoader;
+async function loadResource2(source, config) {
+  const loader = config?.loader ?? new FolderLoader2;
   const canLoad = await loader.canLoad(source);
   if (!canLoad) {
     throw new ResourceXError4(`Cannot load resource from: ${source}`);
@@ -29767,17 +31724,17 @@ async function loadResource(source, config) {
 }
 
 // src/index.ts
-var VERSION = "2.1.1";
+var VERSION = "2.3.0";
 export {
   withDomainValidation,
   textType,
   parseRXL,
-  loadResource,
+  loadResource2 as loadResource,
   jsonType,
   discoverRegistry,
   createRegistry,
   createRXM,
-  createRXC,
+  createRXA,
   builtinTypes,
   binaryType,
   VERSION,
@@ -29789,9 +31746,9 @@ export {
   ManifestError,
   LocatorError,
   LocalRegistry,
-  FolderLoader,
+  FolderLoader2 as FolderLoader,
   DomainValidation,
   ContentError
 };
 
-//# debugId=2E92C4443E9335EE64756E2164756E21
+//# debugId=F895E8556A6AA7E764756E2164756E21