@resourcexjs/registry 0.9.0 → 1.1.0

package/dist/index.js

@@ -1,4 +1,7 @@
 // ../core/dist/index.js
+import { gzip, gunzip } from "node:zlib";
+import { promisify } from "node:util";
+
 class ResourceXError extends Error {
   constructor(message, options) {
     super(message, options);
@@ -11,21 +14,6 @@ class ManifestError extends ResourceXError {
     this.name = "ManifestError";
   }
 }
-
-class ContentError extends ResourceXError {
-  constructor(message) {
-    super(message);
-    this.name = "ContentError";
-  }
-}
-
-class ResourceTypeError extends ResourceXError {
-  constructor(message) {
-    super(message);
-    this.name = "ResourceTypeError";
-  }
-}
-
 class RXLImpl {
   domain;
   path;
@@ -152,84 +140,1171 @@ function createRXM(data) {
     version: data.version
   });
 }
+var BLOCK_SIZE = 512;
+var ZERO_BLOCK = new Uint8Array(BLOCK_SIZE);
+var EMPTY = new Uint8Array(0);
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+var EOF_BUFFER = new Uint8Array(BLOCK_SIZE * 2);
+var gzipAsync = promisify(gzip);
+var gunzipAsync = promisify(gunzip);
 
-class RXCImpl {
-  _stream;
-  _consumed = false;
-  constructor(stream) {
-    this._stream = stream;
+// src/errors.ts
+class RegistryError extends ResourceXError {
+  constructor(message) {
+    super(message);
+    this.name = "RegistryError";
   }
-  get stream() {
-    if (this._consumed) {
-      throw new ContentError("Content has already been consumed");
+}
+// src/ARPRegistry.ts
+import { homedir } from "node:os";
+
+// ../type/dist/index.js
+import { gzip as gzip2, gunzip as gunzip2 } from "node:zlib";
+import { promisify as promisify2 } from "node:util";
+
+class ResourceXError2 extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ResourceXError";
+  }
+}
+
+class ContentError extends ResourceXError2 {
+  constructor(message) {
+    super(message);
+    this.name = "ContentError";
+  }
+}
+
+class RXLImpl2 {
+  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 + "/";
+      }
     }
-    this._consumed = true;
-    return this._stream;
+    result += this.name;
+    if (this.type) {
+      result += "." + this.type;
+    }
+    if (this.version) {
+      result += "@" + this.version;
+    }
+    return result;
   }
-  async text() {
-    const buffer = await this.buffer();
-    return buffer.toString("utf-8");
+}
+function isDomain2(str) {
+  if (str === "localhost")
+    return true;
+  return str.includes(".");
+}
+function parseRXL2(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 buffer() {
-    if (this._consumed) {
-      throw new ContentError("Content has already been consumed");
+  const segments = remaining.split("/");
+  if (segments.length > 1 && isDomain2(segments[0])) {
+    domain = segments[0];
+    const lastSegment = segments[segments.length - 1];
+    if (segments.length > 2) {
+      path = segments.slice(1, -1).join("/");
     }
-    this._consumed = true;
-    const reader = this._stream.getReader();
-    const chunks = [];
+    remaining = lastSegment;
+  } else {
+    remaining = segments.join("/");
+  }
+  const dotIndex = remaining.lastIndexOf(".");
+  if (dotIndex !== -1) {
+    type = remaining.slice(dotIndex + 1);
+    name = remaining.slice(0, dotIndex);
+  } else {
+    name = remaining;
+  }
+  return new RXLImpl2({ domain, path, name, type, version });
+}
+var BLOCK_SIZE2 = 512;
+var BLOCK_SIZE_MASK = 511;
+var DEFAULT_FILE_MODE = 420;
+var DEFAULT_DIR_MODE = 493;
+var USTAR_NAME_OFFSET = 0;
+var USTAR_NAME_SIZE = 100;
+var USTAR_MODE_OFFSET = 100;
+var USTAR_MODE_SIZE = 8;
+var USTAR_UID_OFFSET = 108;
+var USTAR_UID_SIZE = 8;
+var USTAR_GID_OFFSET = 116;
+var USTAR_GID_SIZE = 8;
+var USTAR_SIZE_OFFSET = 124;
+var USTAR_SIZE_SIZE = 12;
+var USTAR_MTIME_OFFSET = 136;
+var USTAR_MTIME_SIZE = 12;
+var USTAR_CHECKSUM_OFFSET = 148;
+var USTAR_CHECKSUM_SIZE = 8;
+var USTAR_TYPEFLAG_OFFSET = 156;
+var USTAR_TYPEFLAG_SIZE = 1;
+var USTAR_LINKNAME_OFFSET = 157;
+var USTAR_LINKNAME_SIZE = 100;
+var USTAR_MAGIC_OFFSET = 257;
+var USTAR_MAGIC_SIZE = 6;
+var USTAR_VERSION_OFFSET = 263;
+var USTAR_VERSION_SIZE = 2;
+var USTAR_UNAME_OFFSET = 265;
+var USTAR_UNAME_SIZE = 32;
+var USTAR_GNAME_OFFSET = 297;
+var USTAR_GNAME_SIZE = 32;
+var USTAR_PREFIX_OFFSET = 345;
+var USTAR_PREFIX_SIZE = 155;
+var USTAR_VERSION = "00";
+var USTAR_MAX_UID_GID = 2097151;
+var USTAR_MAX_SIZE = 8589934591;
+var FILE = "file";
+var LINK = "link";
+var SYMLINK = "symlink";
+var DIRECTORY = "directory";
+var TYPEFLAG = {
+  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 FLAGTYPE = {
+  "0": FILE,
+  "1": LINK,
+  "2": SYMLINK,
+  "3": "character-device",
+  "4": "block-device",
+  "5": DIRECTORY,
+  "6": "fifo",
+  x: "pax-header",
+  g: "pax-global-header",
+  L: "gnu-long-name",
+  K: "gnu-long-link-name"
+};
+var ZERO_BLOCK2 = new Uint8Array(BLOCK_SIZE2);
+var EMPTY2 = new Uint8Array(0);
+var encoder2 = new TextEncoder;
+var decoder2 = new TextDecoder;
+function writeString(view, offset, size, value) {
+  if (value)
+    encoder2.encodeInto(value, view.subarray(offset, offset + size));
+}
+function writeOctal(view, offset, size, value) {
+  if (value === undefined)
+    return;
+  const octalString = value.toString(8).padStart(size - 1, "0");
+  encoder2.encodeInto(octalString, view.subarray(offset, offset + size - 1));
+}
+function readString(view, offset, size) {
+  const end = view.indexOf(0, offset);
+  const sliceEnd = end === -1 || end > offset + size ? offset + size : end;
+  return decoder2.decode(view.subarray(offset, sliceEnd));
+}
+function readOctal(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 readNumeric(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 readOctal(view, offset, size);
+}
+var isBodyless = (header) => header.type === DIRECTORY || header.type === SYMLINK || header.type === LINK;
+async function normalizeBody(body) {
+  if (body === null || body === undefined)
+    return EMPTY2;
+  if (body instanceof Uint8Array)
+    return body;
+  if (typeof body === "string")
+    return encoder2.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 transformHeader(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 === DIRECTORY && !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_SPACE = 32;
+var ASCII_ZERO = 48;
+function validateChecksum(block) {
+  const stored = readOctal(block, USTAR_CHECKSUM_OFFSET, USTAR_CHECKSUM_SIZE);
+  let sum = 0;
+  for (let i = 0;i < block.length; i++)
+    if (i >= USTAR_CHECKSUM_OFFSET && i < USTAR_CHECKSUM_OFFSET + USTAR_CHECKSUM_SIZE)
+      sum += CHECKSUM_SPACE;
+    else
+      sum += block[i];
+  return stored === sum;
+}
+function writeChecksum(block) {
+  block.fill(CHECKSUM_SPACE, USTAR_CHECKSUM_OFFSET, USTAR_CHECKSUM_OFFSET + USTAR_CHECKSUM_SIZE);
+  let checksum = 0;
+  for (const byte of block)
+    checksum += byte;
+  for (let i = USTAR_CHECKSUM_OFFSET + 6 - 1;i >= USTAR_CHECKSUM_OFFSET; i--) {
+    block[i] = (checksum & 7) + ASCII_ZERO;
+    checksum >>= 3;
+  }
+  block[USTAR_CHECKSUM_OFFSET + 6] = 0;
+  block[USTAR_CHECKSUM_OFFSET + 7] = CHECKSUM_SPACE;
+}
+function generatePax(header) {
+  const paxRecords = {};
+  if (header.name.length > USTAR_NAME_SIZE) {
+    if (findUstarSplit(header.name) === null)
+      paxRecords.path = header.name;
+  }
+  if (header.linkname && header.linkname.length > USTAR_NAME_SIZE)
+    paxRecords.linkpath = header.linkname;
+  if (header.uname && header.uname.length > USTAR_UNAME_SIZE)
+    paxRecords.uname = header.uname;
+  if (header.gname && header.gname.length > USTAR_GNAME_SIZE)
+    paxRecords.gname = header.gname;
+  if (header.uid != null && header.uid > USTAR_MAX_UID_GID)
+    paxRecords.uid = String(header.uid);
+  if (header.gid != null && header.gid > USTAR_MAX_UID_GID)
+    paxRecords.gid = String(header.gid);
+  if (header.size != null && header.size > USTAR_MAX_SIZE)
+    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 = encoder2.encode(paxEntries.map(([key, value]) => {
+    const record = `${key}=${value}
+`;
+    const partLength = encoder2.encode(record).length + 1;
+    let totalLength = partLength + String(partLength).length;
+    totalLength = partLength + String(totalLength).length;
+    return `${totalLength} ${record}`;
+  }).join(""));
+  return {
+    paxHeader: createTarHeader({
+      name: decoder2.decode(encoder2.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 findUstarSplit(path) {
+  if (path.length <= USTAR_NAME_SIZE)
+    return null;
+  const minSlashIndex = path.length - USTAR_NAME_SIZE - 1;
+  const slashIndex = path.lastIndexOf("/", USTAR_PREFIX_SIZE);
+  if (slashIndex > 0 && slashIndex >= minSlashIndex)
+    return {
+      prefix: path.slice(0, slashIndex),
+      name: path.slice(slashIndex + 1)
+    };
+  return null;
+}
+function createTarHeader(header) {
+  const view = new Uint8Array(BLOCK_SIZE2);
+  const size = isBodyless(header) ? 0 : header.size ?? 0;
+  let name = header.name;
+  let prefix = "";
+  if (!header.pax?.path) {
+    const split = findUstarSplit(name);
+    if (split) {
+      name = split.name;
+      prefix = split.prefix;
+    }
+  }
+  writeString(view, USTAR_NAME_OFFSET, USTAR_NAME_SIZE, name);
+  writeOctal(view, USTAR_MODE_OFFSET, USTAR_MODE_SIZE, header.mode ?? (header.type === DIRECTORY ? DEFAULT_DIR_MODE : DEFAULT_FILE_MODE));
+  writeOctal(view, USTAR_UID_OFFSET, USTAR_UID_SIZE, header.uid ?? 0);
+  writeOctal(view, USTAR_GID_OFFSET, USTAR_GID_SIZE, header.gid ?? 0);
+  writeOctal(view, USTAR_SIZE_OFFSET, USTAR_SIZE_SIZE, size);
+  writeOctal(view, USTAR_MTIME_OFFSET, USTAR_MTIME_SIZE, Math.floor((header.mtime?.getTime() ?? Date.now()) / 1000));
+  writeString(view, USTAR_TYPEFLAG_OFFSET, USTAR_TYPEFLAG_SIZE, TYPEFLAG[header.type ?? FILE]);
+  writeString(view, USTAR_LINKNAME_OFFSET, USTAR_LINKNAME_SIZE, header.linkname);
+  writeString(view, USTAR_MAGIC_OFFSET, USTAR_MAGIC_SIZE, "ustar\x00");
+  writeString(view, USTAR_VERSION_OFFSET, USTAR_VERSION_SIZE, USTAR_VERSION);
+  writeString(view, USTAR_UNAME_OFFSET, USTAR_UNAME_SIZE, header.uname);
+  writeString(view, USTAR_GNAME_OFFSET, USTAR_GNAME_SIZE, header.gname);
+  writeString(view, USTAR_PREFIX_OFFSET, USTAR_PREFIX_SIZE, prefix);
+  writeChecksum(view);
+  return view;
+}
+function parseUstarHeader(block, strict) {
+  if (strict && !validateChecksum(block))
+    throw new Error("Invalid tar header checksum.");
+  const typeflag = readString(block, USTAR_TYPEFLAG_OFFSET, USTAR_TYPEFLAG_SIZE);
+  const header = {
+    name: readString(block, USTAR_NAME_OFFSET, USTAR_NAME_SIZE),
+    mode: readOctal(block, USTAR_MODE_OFFSET, USTAR_MODE_SIZE),
+    uid: readNumeric(block, USTAR_UID_OFFSET, USTAR_UID_SIZE),
+    gid: readNumeric(block, USTAR_GID_OFFSET, USTAR_GID_SIZE),
+    size: readNumeric(block, USTAR_SIZE_OFFSET, USTAR_SIZE_SIZE),
+    mtime: /* @__PURE__ */ new Date(readNumeric(block, USTAR_MTIME_OFFSET, USTAR_MTIME_SIZE) * 1000),
+    type: FLAGTYPE[typeflag] || FILE,
+    linkname: readString(block, USTAR_LINKNAME_OFFSET, USTAR_LINKNAME_SIZE)
+  };
+  const magic = readString(block, USTAR_MAGIC_OFFSET, USTAR_MAGIC_SIZE);
+  if (magic.trim() === "ustar") {
+    header.uname = readString(block, USTAR_UNAME_OFFSET, USTAR_UNAME_SIZE);
+    header.gname = readString(block, USTAR_GNAME_OFFSET, USTAR_GNAME_SIZE);
+  }
+  if (magic === "ustar")
+    header.prefix = readString(block, USTAR_PREFIX_OFFSET, USTAR_PREFIX_SIZE);
+  return header;
+}
+var PAX_MAPPING = {
+  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 parsePax(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_MAPPING[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 applyOverrides(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 getMetaParser(type) {
+  switch (type) {
+    case "pax-global-header":
+    case "pax-header":
+      return parsePax;
+    case "gnu-long-name":
+      return (data) => ({ name: readString(data, 0, data.length) });
+    case "gnu-long-link-name":
+      return (data) => ({ linkname: readString(data, 0, data.length) });
+    default:
+      return;
+  }
+}
+function getHeaderBlocks(header) {
+  const base = createTarHeader(header);
+  const pax = generatePax(header);
+  if (!pax)
+    return [base];
+  const paxPadding = -pax.paxBody.length & BLOCK_SIZE_MASK;
+  const paddingBlocks = paxPadding > 0 ? [ZERO_BLOCK2.subarray(0, paxPadding)] : [];
+  return [
+    pax.paxHeader,
+    pax.paxBody,
+    ...paddingBlocks,
+    base
+  ];
+}
+var EOF_BUFFER2 = new Uint8Array(BLOCK_SIZE2 * 2);
+function createTarPacker(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 = isBodyless(header) ? 0 : header.size ?? 0;
+        const headerBlocks = getHeaderBlocks({
+          ...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_MASK;
+        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_BUFFER2);
+        finalized = true;
+        if (onFinalize)
+          onFinalize();
+      } catch (error) {
+        onError(error);
+      }
+    }
+  };
+}
+var INITIAL_CAPACITY = 256;
+function createChunkQueue() {
+  let chunks = new Array(INITIAL_CAPACITY);
+  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] = EMPTY2;
+      head = head + 1 & capacityMask;
+    } else
+      chunks[head] = chunk.subarray(count);
+    totalAvailable -= count;
+    if (totalAvailable === 0 && chunks.length > INITIAL_CAPACITY) {
+      chunks = new Array(INITIAL_CAPACITY);
+      capacityMask = INITIAL_CAPACITY - 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 EMPTY2;
+    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 EMPTY2;
+      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_HEADER = 0;
+var STATE_BODY = 1;
+var truncateErr = /* @__PURE__ */ new Error("Tar archive is truncated.");
+function createUnpacker(options = {}) {
+  const strict = options.strict ?? false;
+  const { available, peek, push, discard, pull } = createChunkQueue();
+  let state = STATE_HEADER;
+  let ended = false;
+  let done = false;
+  let eof = false;
+  let currentEntry = null;
+  const paxGlobals = {};
+  let nextEntryOverrides = {};
+  const unpacker = {
+    isEntryActive: () => state === STATE_BODY,
+    isBodyComplete: () => !currentEntry || currentEntry.remaining === 0,
+    write(chunk) {
+      if (ended)
+        throw new Error("Archive already ended.");
+      push(chunk);
+    },
+    end() {
+      ended = true;
+    },
+    readHeader() {
+      if (state !== STATE_HEADER)
+        throw new Error("Cannot read header while an entry is active");
+      if (done)
+        return;
+      while (!done) {
+        if (available() < BLOCK_SIZE2) {
+          if (ended) {
+            if (available() > 0 && strict)
+              throw truncateErr;
+            done = true;
+            return;
+          }
+          return null;
+        }
+        const headerBlock = peek(BLOCK_SIZE2);
+        if (isZeroBlock(headerBlock)) {
+          if (available() < BLOCK_SIZE2 * 2) {
+            if (ended) {
+              if (strict)
+                throw truncateErr;
+              done = true;
+              return;
+            }
+            return null;
+          }
+          if (isZeroBlock(peek(BLOCK_SIZE2 * 2).subarray(BLOCK_SIZE2))) {
+            discard(BLOCK_SIZE2 * 2);
+            done = true;
+            eof = true;
+            return;
+          }
+          if (strict)
+            throw new Error("Invalid tar header.");
+          discard(BLOCK_SIZE2);
+          continue;
+        }
+        let internalHeader;
+        try {
+          internalHeader = parseUstarHeader(headerBlock, strict);
+        } catch (err) {
+          if (strict)
+            throw err;
+          discard(BLOCK_SIZE2);
+          continue;
+        }
+        const metaParser = getMetaParser(internalHeader.type);
+        if (metaParser) {
+          const paddedSize = internalHeader.size + BLOCK_SIZE_MASK & ~BLOCK_SIZE_MASK;
+          if (available() < BLOCK_SIZE2 + paddedSize) {
+            if (ended && strict)
+              throw truncateErr;
+            return null;
+          }
+          discard(BLOCK_SIZE2);
+          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_SIZE2);
+        const header = internalHeader;
+        if (internalHeader.prefix)
+          header.name = `${internalHeader.prefix}/${header.name}`;
+        applyOverrides(header, paxGlobals);
+        applyOverrides(header, nextEntryOverrides);
+        nextEntryOverrides = {};
+        currentEntry = {
+          header,
+          remaining: header.size,
+          padding: -header.size & BLOCK_SIZE_MASK
+        };
+        state = STATE_BODY;
+        return header;
+      }
+    },
+    streamBody(callback) {
+      if (state !== STATE_BODY || !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_BODY || !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_HEADER;
+      return true;
+    },
+    skipEntry() {
+      if (state !== STATE_BODY || !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 truncateErr;
+        if (available() > 0) {
+          if (pull(available()).some((byte) => byte !== 0))
+            throw new Error("Invalid EOF.");
+        }
+      }
+    }
+  };
+  return unpacker;
+}
+function isZeroBlock(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 createTarPacker2() {
+  let streamController;
+  let packer;
+  return {
+    readable: new ReadableStream({ start(controller) {
+      streamController = controller;
+      packer = createTarPacker(controller.enqueue.bind(controller), controller.error.bind(controller), controller.close.bind(controller));
+    } }),
+    controller: {
+      add(header) {
+        const bodyless = isBodyless(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 streamToBuffer(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 Buffer.concat(chunks);
+    return result;
+  } finally {
+    reader.releaseLock();
   }
-  async json() {
-    const text = await this.text();
-    return JSON.parse(text);
+}
+var drain = (stream) => stream.pipeTo(new WritableStream);
+function createTarDecoder(options = {}) {
+  const unpacker = createUnpacker(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 packTar(entries) {
+  const { readable, controller } = createTarPacker2();
+  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 normalizeBody(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 streamToBuffer(readable));
+}
+async function unpackTar(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(createTarDecoder(options));
+  for await (const entry of entryStream) {
+    let processedHeader;
+    try {
+      processedHeader = transformHeader(entry.header, options);
+    } catch (error) {
+      await entry.body.cancel();
+      throw error;
+    }
+    if (processedHeader === null) {
+      await drain(entry.body);
+      continue;
+    }
+    if (isBodyless(processedHeader)) {
+      await drain(entry.body);
+      results.push({ header: processedHeader });
+    } else
+      results.push({
+        header: processedHeader,
+        data: await streamToBuffer(entry.body)
+      });
   }
+  return results;
 }
-function createRXC(data) {
-  let stream;
-  if (typeof data === "string") {
-    const encoded = new TextEncoder().encode(data);
-    stream = new ReadableStream({
+var gzipAsync2 = promisify2(gzip2);
+var gunzipAsync2 = promisify2(gunzip2);
+
+class RXCImpl {
+  _buffer;
+  _filesCache = null;
+  constructor(buffer) {
+    this._buffer = buffer;
+  }
+  get stream() {
+    const buffer = this._buffer;
+    return new ReadableStream({
       start(controller) {
-        controller.enqueue(encoded);
+        controller.enqueue(new Uint8Array(buffer));
         controller.close();
       }
     });
-  } else if (Buffer.isBuffer(data)) {
-    stream = new ReadableStream({
-      start(controller) {
-        controller.enqueue(new Uint8Array(data));
-        controller.close();
+  }
+  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;
+    }
+    const tarBuffer = await gunzipAsync2(this._buffer);
+    const entries = await unpackTar(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));
       }
-    });
-  } else {
-    stream = data;
+    }
+    this._filesCache = filesMap;
+    return filesMap;
+  }
+}
+function isArchiveInput(input) {
+  return "archive" in input && Buffer.isBuffer(input.archive);
+}
+async function createRXC(input) {
+  if (isArchiveInput(input)) {
+    return new RXCImpl(input.archive);
+  }
+  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 packTar(entries);
+  const gzipBuffer = await gzipAsync2(Buffer.from(tarBuffer));
+  return new RXCImpl(gzipBuffer);
+}
+
+class ResourceTypeError extends ResourceXError2 {
+  constructor(message) {
+    super(message);
+    this.name = "ResourceTypeError";
   }
-  return new RXCImpl(stream);
 }
-var resourceTypes = new Map;
 var textSerializer = {
   async serialize(rxr) {
-    const text = await rxr.content.text();
-    return Buffer.from(text, "utf-8");
+    return rxr.content.buffer();
   },
   async deserialize(data, manifest) {
-    const text = data.toString("utf-8");
     return {
-      locator: parseRXL(manifest.toLocator()),
+      locator: parseRXL2(manifest.toLocator()),
       manifest,
-      content: createRXC(text)
+      content: await createRXC({ archive: data })
     };
   }
 };
 var textResolver = {
   async resolve(rxr) {
-    return rxr.content.text();
+    const buffer = await rxr.content.file("content");
+    return buffer.toString("utf-8");
   }
 };
 var textType = {
@@ -241,21 +1316,20 @@ var textType = {
 };
 var jsonSerializer = {
   async serialize(rxr) {
-    const json = await rxr.content.json();
-    return Buffer.from(JSON.stringify(json, null, 2), "utf-8");
+    return rxr.content.buffer();
   },
   async deserialize(data, manifest) {
-    const text = data.toString("utf-8");
     return {
-      locator: parseRXL(manifest.toLocator()),
+      locator: parseRXL2(manifest.toLocator()),
       manifest,
-      content: createRXC(text)
+      content: await createRXC({ archive: data })
     };
   }
 };
 var jsonResolver = {
   async resolve(rxr) {
-    return rxr.content.json();
+    const buffer = await rxr.content.file("content");
+    return JSON.parse(buffer.toString("utf-8"));
   }
 };
 var jsonType = {
@@ -271,15 +1345,15 @@ var binarySerializer = {
   },
   async deserialize(data, manifest) {
     return {
-      locator: parseRXL(manifest.toLocator()),
+      locator: parseRXL2(manifest.toLocator()),
       manifest,
-      content: createRXC(data)
+      content: await createRXC({ archive: data })
     };
   }
 };
 var binaryResolver = {
   async resolve(rxr) {
-    return rxr.content.buffer();
+    return rxr.content.file("content");
   }
 };
 var binaryType = {
@@ -292,8 +1366,20 @@ var binaryType = {
 var builtinTypes = [textType, jsonType, binaryType];
 
 class TypeHandlerChain {
+  static instance;
   handlers = new Map;
-  register(type) {
+  constructor() {
+    for (const type of builtinTypes) {
+      this.registerBuiltin(type);
+    }
+  }
+  static getInstance() {
+    if (!TypeHandlerChain.instance) {
+      TypeHandlerChain.instance = new TypeHandlerChain;
+    }
+    return TypeHandlerChain.instance;
+  }
+  registerBuiltin(type) {
     this.handlers.set(type.name, type);
     if (type.aliases) {
       for (const alias of type.aliases) {
@@ -301,9 +1387,18 @@ class TypeHandlerChain {
       }
     }
   }
-  registerAll(types) {
-    for (const type of types) {
-      this.register(type);
+  register(type) {
+    if (this.handlers.has(type.name)) {
+      throw new ResourceTypeError(`Type '${type.name}' is already registered`);
+    }
+    this.handlers.set(type.name, type);
+    if (type.aliases) {
+      for (const alias of type.aliases) {
+        if (this.handlers.has(alias)) {
+          throw new ResourceTypeError(`Alias '${alias}' conflicts with existing type or alias`);
+        }
+        this.handlers.set(alias, type);
+      }
     }
   }
   canHandle(typeName) {
@@ -312,6 +1407,9 @@ class TypeHandlerChain {
   getHandler(typeName) {
     return this.handlers.get(typeName);
   }
+  getSupportedTypes() {
+    return Array.from(this.handlers.keys());
+  }
   async serialize(rxr) {
     const typeName = rxr.manifest.type;
     const handler = this.handlers.get(typeName);
@@ -336,24 +1434,14 @@ class TypeHandlerChain {
     }
     return handler.resolver.resolve(rxr);
   }
-}
-function createTypeHandlerChain(types) {
-  const chain = new TypeHandlerChain;
-  if (types) {
-    chain.registerAll(types);
-  }
-  return chain;
-}
-
-// src/errors.ts
-class RegistryError extends ResourceXError {
-  constructor(message) {
-    super(message);
-    this.name = "RegistryError";
+  clearExtensions() {
+    this.handlers.clear();
+    for (const type of builtinTypes) {
+      this.registerBuiltin(type);
+    }
   }
 }
-// src/ARPRegistry.ts
-import { homedir } from "node:os";
+var globalTypeHandlerChain = TypeHandlerChain.getInstance();
 
 // ../arp/dist/index.js
 import { readFile, writeFile, readdir, mkdir, rm, access, stat as fsStat } from "node:fs/promises";
@@ -788,11 +1876,14 @@ var DEFAULT_PATH = `${homedir()}/.resourcex`;
 class ARPRegistry {
   arp;
   basePath;
-  typeChain;
   constructor(config) {
     this.arp = createARP();
     this.basePath = config?.path ?? DEFAULT_PATH;
-    this.typeChain = createTypeHandlerChain([...builtinTypes, ...config?.types ?? []]);
+    if (config?.types) {
+      for (const type of config.types) {
+        globalTypeHandlerChain.register(type);
+      }
+    }
   }
   buildUrl(locator, filename) {
     const rxl = typeof locator === "string" ? parseRXL(locator) : locator;
@@ -814,7 +1905,7 @@ class ARPRegistry {
     await manifestArl.deposit(JSON.stringify(resource.manifest.toJSON(), null, 2));
     const contentUrl = this.buildUrl(locator, "content").replace("arp:text:", "arp:binary:");
     const contentArl = this.arp.parse(contentUrl);
-    const serialized = await this.typeChain.serialize(resource);
+    const serialized = await globalTypeHandlerChain.serialize(resource);
     await contentArl.deposit(serialized);
   }
   async resolve(locator) {
@@ -830,7 +1921,7 @@ class ARPRegistry {
     const contentArl = this.arp.parse(contentUrl);
     const contentResult = await contentArl.resolve();
     const data = contentResult.content;
-    return this.typeChain.deserialize(data, manifest);
+    return globalTypeHandlerChain.deserialize(data, manifest);
   }
   async exists(locator) {
     const manifestUrl = this.buildUrl(locator, "manifest.json");
@@ -862,4 +1953,4 @@ export {
   ARPRegistry
 };
 
-//# debugId=F946E1BEB367C85D64756E2164756E21
+//# debugId=6B85BCB12D2565AC64756E2164756E21