resourcexjs 2.5.5 → 2.5.7

package/dist/arp.js

@@ -10,1194 +10,6 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// ../core/dist/index.js
-var exports_dist = {};
-__export(exports_dist, {
-  wrap: () => wrap,
-  resource: () => resource,
-  parse: () => parse,
-  manifest: () => manifest,
-  locate: () => locate,
-  format: () => format,
-  extract: () => extract,
-  define: () => define,
-  archive: () => archive,
-  ResourceXError: () => ResourceXError,
-  ManifestError: () => ManifestError,
-  LocatorError: () => LocatorError,
-  DefinitionError: () => DefinitionError,
-  ContentError: () => ContentError
-});
-import { gzip } from "node:zlib";
-import { promisify } from "node:util";
-import { gunzip } from "node:zlib";
-import { promisify as promisify2 } from "node:util";
-function define(input) {
-  if (input === null || typeof input !== "object") {
-    throw new DefinitionError("definition must be an object");
-  }
-  const obj = input;
-  if (!obj.name || typeof obj.name !== "string") {
-    throw new DefinitionError("name is required");
-  }
-  if (!obj.type || typeof obj.type !== "string") {
-    throw new DefinitionError("type is required");
-  }
-  const tagValue = obj.tag ?? obj.version;
-  if (tagValue !== undefined && typeof tagValue !== "string") {
-    throw new DefinitionError("tag must be a string");
-  }
-  const rxd = {
-    ...obj,
-    name: obj.name,
-    type: obj.type,
-    tag: typeof tagValue === "string" ? tagValue : undefined,
-    registry: typeof obj.registry === "string" ? obj.registry : undefined,
-    path: typeof obj.path === "string" ? obj.path : undefined,
-    description: typeof obj.description === "string" ? obj.description : undefined,
-    author: typeof obj.author === "string" ? obj.author : undefined,
-    license: typeof obj.license === "string" ? obj.license : undefined,
-    keywords: Array.isArray(obj.keywords) ? obj.keywords : undefined,
-    repository: typeof obj.repository === "string" ? obj.repository : undefined
-  };
-  return rxd;
-}
-function manifest(rxd) {
-  return {
-    registry: rxd.registry,
-    path: rxd.path,
-    name: rxd.name,
-    type: rxd.type,
-    tag: rxd.tag ?? "latest"
-  };
-}
-function writeString(view, offset, size, value) {
-  if (value)
-    encoder.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");
-  encoder.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 decoder.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);
-}
-async function normalizeBody(body) {
-  if (body === null || body === undefined)
-    return EMPTY;
-  if (body instanceof Uint8Array)
-    return body;
-  if (typeof body === "string")
-    return encoder.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;
-}
-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 = encoder.encode(paxEntries.map(([key, value]) => {
-    const record = `${key}=${value}
-`;
-    const partLength = encoder.encode(record).length + 1;
-    let totalLength = partLength + String(partLength).length;
-    totalLength = partLength + String(totalLength).length;
-    return `${totalLength} ${record}`;
-  }).join(""));
-  return {
-    paxHeader: createTarHeader({
-      name: decoder.decode(encoder.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_SIZE);
-  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;
-}
-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_BLOCK.subarray(0, paxPadding)] : [];
-  return [
-    pax.paxHeader,
-    pax.paxBody,
-    ...paddingBlocks,
-    base
-  ];
-}
-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_BUFFER);
-        finalized = true;
-        if (onFinalize)
-          onFinalize();
-      } catch (error) {
-        onError(error);
-      }
-    }
-  };
-}
-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] = EMPTY;
-      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 EMPTY;
-    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 EMPTY;
-      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
-  };
-}
-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_SIZE) {
-          if (ended) {
-            if (available() > 0 && strict)
-              throw truncateErr;
-            done = true;
-            return;
-          }
-          return null;
-        }
-        const headerBlock = peek(BLOCK_SIZE);
-        if (isZeroBlock(headerBlock)) {
-          if (available() < BLOCK_SIZE * 2) {
-            if (ended) {
-              if (strict)
-                throw truncateErr;
-              done = true;
-              return;
-            }
-            return null;
-          }
-          if (isZeroBlock(peek(BLOCK_SIZE * 2).subarray(BLOCK_SIZE))) {
-            discard(BLOCK_SIZE * 2);
-            done = true;
-            eof = true;
-            return;
-          }
-          if (strict)
-            throw new Error("Invalid tar header.");
-          discard(BLOCK_SIZE);
-          continue;
-        }
-        let internalHeader;
-        try {
-          internalHeader = parseUstarHeader(headerBlock, strict);
-        } catch (err) {
-          if (strict)
-            throw err;
-          discard(BLOCK_SIZE);
-          continue;
-        }
-        const metaParser = getMetaParser(internalHeader.type);
-        if (metaParser) {
-          const paddedSize = internalHeader.size + BLOCK_SIZE_MASK & ~BLOCK_SIZE_MASK;
-          if (available() < BLOCK_SIZE + paddedSize) {
-            if (ended && strict)
-              throw truncateErr;
-            return null;
-          }
-          discard(BLOCK_SIZE);
-          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_SIZE);
-        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 result;
-  } finally {
-    reader.releaseLock();
-  }
-}
-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;
-}
-
-class RXAImpl {
-  _buffer;
-  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 function archive(files) {
-  const entries = Object.entries(files).map(([name, content]) => {
-    return {
-      header: { name, size: content.length, type: "file" },
-      body: new Uint8Array(content)
-    };
-  });
-  const tarBuffer = await packTar(entries);
-  const gzipBuffer = await gzipAsync(Buffer.from(tarBuffer));
-  return new RXAImpl(gzipBuffer);
-}
-function locate(rxm) {
-  return {
-    registry: rxm.registry,
-    path: rxm.path,
-    name: rxm.name,
-    tag: rxm.tag
-  };
-}
-function resource(rxm, rxa) {
-  const rxl = locate(rxm);
-  return {
-    locator: rxl,
-    manifest: rxm,
-    archive: rxa
-  };
-}
-async function extract(rxa) {
-  const buffer = await rxa.buffer();
-  const tarBuffer = await gunzipAsync(buffer);
-  const entries = await unpackTar(tarBuffer);
-  const files = {};
-  for (const entry of entries) {
-    if ((entry.header.type === "file" || entry.header.type === undefined) && entry.data) {
-      files[entry.header.name] = Buffer.from(entry.data);
-    }
-  }
-  return files;
-}
-function format(rxl) {
-  let result = "";
-  if (rxl.registry) {
-    result += rxl.registry + "/";
-  }
-  if (rxl.path) {
-    result += rxl.path + "/";
-  }
-  result += rxl.name;
-  if (rxl.tag && rxl.tag !== "latest") {
-    result += ":" + rxl.tag;
-  }
-  return result;
-}
-function looksLikeRegistry(str) {
-  if (str.includes(":") && !str.includes("/")) {
-    return true;
-  }
-  if (str.includes(".")) {
-    return true;
-  }
-  if (str === "localhost") {
-    return true;
-  }
-  return false;
-}
-function parse(locator) {
-  if (!locator || typeof locator !== "string") {
-    throw new LocatorError("Locator must be a non-empty string", locator);
-  }
-  if (locator.includes("@")) {
-    throw new LocatorError("Invalid locator format. Use name:tag instead of name@version", locator);
-  }
-  const lastSlashIndex = locator.lastIndexOf("/");
-  let beforeSlash = "";
-  let afterSlash = locator;
-  if (lastSlashIndex !== -1) {
-    beforeSlash = locator.substring(0, lastSlashIndex);
-    afterSlash = locator.substring(lastSlashIndex + 1);
-  }
-  const colonIndex = afterSlash.lastIndexOf(":");
-  let name;
-  let tag;
-  if (colonIndex === -1) {
-    name = afterSlash;
-    tag = "latest";
-  } else {
-    name = afterSlash.substring(0, colonIndex);
-    tag = afterSlash.substring(colonIndex + 1);
-  }
-  if (!name) {
-    throw new LocatorError("Name is required", locator);
-  }
-  if (!tag) {
-    throw new LocatorError("Tag cannot be empty. Use name:tag format or omit tag for :latest", locator);
-  }
-  if (lastSlashIndex === -1) {
-    return {
-      registry: undefined,
-      path: undefined,
-      name,
-      tag
-    };
-  }
-  const parts = beforeSlash.split("/");
-  if (looksLikeRegistry(parts[0])) {
-    const registry = parts[0];
-    const path = parts.length > 1 ? parts.slice(1).join("/") : undefined;
-    return {
-      registry,
-      path,
-      name,
-      tag
-    };
-  }
-  return {
-    registry: undefined,
-    path: beforeSlash,
-    name,
-    tag
-  };
-}
-
-class RXAImpl2 {
-  _buffer;
-  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;
-  }
-}
-function wrap(buffer) {
-  return new RXAImpl2(buffer);
-}
-var ResourceXError, LocatorError, ManifestError, ContentError, DefinitionError, BLOCK_SIZE = 512, BLOCK_SIZE_MASK = 511, DEFAULT_FILE_MODE = 420, DEFAULT_DIR_MODE = 493, USTAR_NAME_OFFSET = 0, USTAR_NAME_SIZE = 100, USTAR_MODE_OFFSET = 100, USTAR_MODE_SIZE = 8, USTAR_UID_OFFSET = 108, USTAR_UID_SIZE = 8, USTAR_GID_OFFSET = 116, USTAR_GID_SIZE = 8, USTAR_SIZE_OFFSET = 124, USTAR_SIZE_SIZE = 12, USTAR_MTIME_OFFSET = 136, USTAR_MTIME_SIZE = 12, USTAR_CHECKSUM_OFFSET = 148, USTAR_CHECKSUM_SIZE = 8, USTAR_TYPEFLAG_OFFSET = 156, USTAR_TYPEFLAG_SIZE = 1, USTAR_LINKNAME_OFFSET = 157, USTAR_LINKNAME_SIZE = 100, USTAR_MAGIC_OFFSET = 257, USTAR_MAGIC_SIZE = 6, USTAR_VERSION_OFFSET = 263, USTAR_VERSION_SIZE = 2, USTAR_UNAME_OFFSET = 265, USTAR_UNAME_SIZE = 32, USTAR_GNAME_OFFSET = 297, USTAR_GNAME_SIZE = 32, USTAR_PREFIX_OFFSET = 345, USTAR_PREFIX_SIZE = 155, USTAR_VERSION = "00", USTAR_MAX_UID_GID = 2097151, USTAR_MAX_SIZE = 8589934591, FILE = "file", LINK = "link", SYMLINK = "symlink", DIRECTORY = "directory", TYPEFLAG, FLAGTYPE, ZERO_BLOCK, EMPTY, encoder, decoder, isBodyless = (header) => header.type === DIRECTORY || header.type === SYMLINK || header.type === LINK, CHECKSUM_SPACE = 32, ASCII_ZERO = 48, PAX_MAPPING, EOF_BUFFER, INITIAL_CAPACITY = 256, STATE_HEADER = 0, STATE_BODY = 1, truncateErr, drain = (stream) => stream.pipeTo(new WritableStream), gzipAsync, gunzipAsync;
-var init_dist = __esm(() => {
-  ResourceXError = class ResourceXError extends Error {
-    constructor(message, options) {
-      super(message, options);
-      this.name = "ResourceXError";
-    }
-  };
-  LocatorError = class LocatorError extends ResourceXError {
-    locator;
-    constructor(message, locator) {
-      super(message);
-      this.locator = locator;
-      this.name = "LocatorError";
-    }
-  };
-  ManifestError = class ManifestError extends ResourceXError {
-    constructor(message) {
-      super(message);
-      this.name = "ManifestError";
-    }
-  };
-  ContentError = class ContentError extends ResourceXError {
-    constructor(message) {
-      super(message);
-      this.name = "ContentError";
-    }
-  };
-  DefinitionError = class DefinitionError extends ResourceXError {
-    constructor(message) {
-      super(message);
-      this.name = "DefinitionError";
-    }
-  };
-  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"
-  };
-  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"
-  };
-  ZERO_BLOCK = new Uint8Array(BLOCK_SIZE);
-  EMPTY = new Uint8Array(0);
-  encoder = new TextEncoder;
-  decoder = new TextDecoder;
-  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]
-  };
-  EOF_BUFFER = new Uint8Array(BLOCK_SIZE * 2);
-  truncateErr = /* @__PURE__ */ new Error("Tar archive is truncated.");
-  gzipAsync = promisify(gzip);
-  gunzipAsync = promisify2(gunzip);
-});
-
 // ../arp/dist/index.js
 import { readFile, writeFile, readdir, mkdir, rm, access, stat } from "node:fs/promises";
 import { resolve, dirname, join } from "node:path";
@@ -1714,1455 +526,18 @@ class ARP {
 function createARP(config) {
   return new ARP(config);
 }
-var VERSION = "2.5.5";
-
-// src/transport/rxr.ts
-import { homedir } from "node:os";
-import { join as join4 } from "node:path";
-init_dist();
-
-// ../storage/dist/index.js
-import { join as join2, dirname as dirname2 } from "node:path";
-import { readFile as readFile2, writeFile as writeFile2, rm as rm2, access as access2, readdir as readdir2, mkdir as mkdir2 } from "node:fs/promises";
-
-class StorageError extends Error {
-  code;
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "StorageError";
-  }
-}
-
-class FileSystemStorage {
-  basePath;
-  constructor(basePath) {
-    this.basePath = basePath;
-  }
-  async get(key) {
-    const filePath = join2(this.basePath, key);
-    try {
-      return await readFile2(filePath);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        throw new StorageError(`Key not found: ${key}`, "NOT_FOUND");
-      }
-      throw new StorageError(`Failed to read: ${key}`, "READ_ERROR");
-    }
-  }
-  async put(key, data) {
-    const filePath = join2(this.basePath, key);
-    try {
-      await mkdir2(dirname2(filePath), { recursive: true });
-      await writeFile2(filePath, data);
-    } catch {
-      throw new StorageError(`Failed to write: ${key}`, "WRITE_ERROR");
-    }
-  }
-  async delete(key) {
-    const filePath = join2(this.basePath, key);
-    try {
-      await rm2(filePath, { recursive: true, force: true });
-    } catch {
-      throw new StorageError(`Failed to delete: ${key}`, "DELETE_ERROR");
-    }
-  }
-  async exists(key) {
-    const filePath = join2(this.basePath, key);
-    try {
-      await access2(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async list(prefix) {
-    const searchPath = prefix ? join2(this.basePath, prefix) : this.basePath;
-    const results = [];
-    try {
-      await this.listRecursive(searchPath, prefix ?? "", results);
-    } catch {
-      return [];
-    }
-    return results;
-  }
-  async listRecursive(dirPath, prefix, results) {
-    const entries = await readdir2(dirPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) {
-        await this.listRecursive(join2(dirPath, entry.name), relativePath, results);
-      } else {
-        results.push(relativePath);
-      }
-    }
-  }
-}
-
-class MemoryStorage {
-  data = new Map;
-  async get(key) {
-    const value = this.data.get(key);
-    if (!value) {
-      throw new StorageError(`Key not found: ${key}`, "NOT_FOUND");
-    }
-    return value;
-  }
-  async put(key, data) {
-    this.data.set(key, data);
-  }
-  async delete(key) {
-    for (const k of this.data.keys()) {
-      if (k === key || k.startsWith(`${key}/`)) {
-        this.data.delete(k);
-      }
-    }
-  }
-  async exists(key) {
-    return this.data.has(key);
-  }
-  async list(prefix) {
-    const results = [];
-    for (const key of this.data.keys()) {
-      if (!prefix || key.startsWith(prefix)) {
-        results.push(key);
-      }
-    }
-    return results;
-  }
-  clear() {
-    this.data.clear();
-  }
-  size() {
-    return this.data.size;
-  }
-}
-
-// ../registry/dist/index.js
-import { gzip as gzip2 } from "node:zlib";
-import { promisify as promisify3 } from "node:util";
-import { gunzip as gunzip2 } from "node:zlib";
-import { promisify as promisify22 } from "node:util";
-import { join as join22, resolve as resolvePath } from "node:path";
-import { symlink, lstat, readlink, rm as rm3, mkdir as mkdir3, readdir as readdir22 } from "node:fs/promises";
-import { join as join3, relative } from "node:path";
-import { stat as stat2, readFile as readFile3, readdir as readdir3 } from "node:fs/promises";
-import { gzip as gzip22 } from "node:zlib";
-import { promisify as promisify32 } from "node:util";
-import { gunzip as gunzip22 } from "node:zlib";
-import { promisify as promisify222 } from "node:util";
-
-class ResourceXError2 extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ResourceXError";
-  }
-}
-
-class LocatorError2 extends ResourceXError2 {
-  locator;
-  constructor(message, locator) {
-    super(message);
-    this.locator = locator;
-    this.name = "LocatorError";
-  }
-}
-var BLOCK_SIZE2 = 512;
-var ZERO_BLOCK2 = new Uint8Array(BLOCK_SIZE2);
-var EMPTY2 = new Uint8Array(0);
-var encoder2 = new TextEncoder;
-var decoder2 = new TextDecoder;
-var EOF_BUFFER2 = new Uint8Array(BLOCK_SIZE2 * 2);
-var gzipAsync2 = promisify3(gzip2);
-function locate2(rxm) {
-  return {
-    registry: rxm.registry,
-    path: rxm.path,
-    name: rxm.name,
-    tag: rxm.tag
-  };
-}
-function resource2(rxm, rxa) {
-  const rxl = locate2(rxm);
-  return {
-    locator: rxl,
-    manifest: rxm,
-    archive: rxa
-  };
-}
-var gunzipAsync2 = promisify22(gunzip2);
-function format2(rxl) {
-  let result = "";
-  if (rxl.registry) {
-    result += rxl.registry + "/";
-  }
-  if (rxl.path) {
-    result += rxl.path + "/";
-  }
-  result += rxl.name;
-  if (rxl.tag && rxl.tag !== "latest") {
-    result += ":" + rxl.tag;
-  }
-  return result;
-}
-function looksLikeRegistry2(str) {
-  if (str.includes(":") && !str.includes("/")) {
-    return true;
-  }
-  if (str.includes(".")) {
-    return true;
-  }
-  if (str === "localhost") {
-    return true;
-  }
-  return false;
-}
-function parse2(locator) {
-  if (!locator || typeof locator !== "string") {
-    throw new LocatorError2("Locator must be a non-empty string", locator);
-  }
-  if (locator.includes("@")) {
-    throw new LocatorError2("Invalid locator format. Use name:tag instead of name@version", locator);
-  }
-  const lastSlashIndex = locator.lastIndexOf("/");
-  let beforeSlash = "";
-  let afterSlash = locator;
-  if (lastSlashIndex !== -1) {
-    beforeSlash = locator.substring(0, lastSlashIndex);
-    afterSlash = locator.substring(lastSlashIndex + 1);
-  }
-  const colonIndex = afterSlash.lastIndexOf(":");
-  let name;
-  let tag;
-  if (colonIndex === -1) {
-    name = afterSlash;
-    tag = "latest";
-  } else {
-    name = afterSlash.substring(0, colonIndex);
-    tag = afterSlash.substring(colonIndex + 1);
-  }
-  if (!name) {
-    throw new LocatorError2("Name is required", locator);
-  }
-  if (!tag) {
-    throw new LocatorError2("Tag cannot be empty. Use name:tag format or omit tag for :latest", locator);
-  }
-  if (lastSlashIndex === -1) {
-    return {
-      registry: undefined,
-      path: undefined,
-      name,
-      tag
-    };
-  }
-  const parts = beforeSlash.split("/");
-  if (looksLikeRegistry2(parts[0])) {
-    const registry = parts[0];
-    const path = parts.length > 1 ? parts.slice(1).join("/") : undefined;
-    return {
-      registry,
-      path,
-      name,
-      tag
-    };
-  }
-  return {
-    registry: undefined,
-    path: beforeSlash,
-    name,
-    tag
-  };
-}
-
-class RXAImpl22 {
-  _buffer;
-  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;
-  }
-}
-function wrap2(buffer) {
-  return new RXAImpl22(buffer);
-}
-
-class RegistryError extends ResourceXError2 {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "RegistryError";
-  }
-}
-
-class LocalRegistry {
-  storage;
-  constructor(storage) {
-    this.storage = storage;
-  }
-  buildKeyPrefix(rxl) {
-    const tag = rxl.tag ?? "latest";
-    let key = rxl.name;
-    if (rxl.path) {
-      key = `${rxl.path}/${key}`;
-    }
-    key += `/${tag}`;
-    return key;
-  }
-  async get(rxl) {
-    const prefix = this.buildKeyPrefix(rxl);
-    const manifestKey = `${prefix}/manifest.json`;
-    const archiveKey = `${prefix}/archive.tar.gz`;
-    let manifestData;
-    try {
-      manifestData = await this.storage.get(manifestKey);
-    } catch {
-      throw new RegistryError(`Resource not found: ${format2(rxl)}`);
-    }
-    const manifestJson = JSON.parse(manifestData.toString("utf-8"));
-    const rxm = {
-      registry: manifestJson.registry,
-      path: manifestJson.path,
-      name: manifestJson.name,
-      type: manifestJson.type,
-      tag: manifestJson.tag,
-      files: manifestJson.files
-    };
-    const archiveData = await this.storage.get(archiveKey);
-    const rxa = wrap2(archiveData);
-    return resource2(rxm, rxa);
-  }
-  async put(rxr) {
-    const prefix = this.buildKeyPrefix(rxr.locator);
-    const manifestKey = `${prefix}/manifest.json`;
-    const archiveKey = `${prefix}/archive.tar.gz`;
-    const manifestJson = {
-      registry: rxr.manifest.registry,
-      path: rxr.manifest.path,
-      name: rxr.manifest.name,
-      type: rxr.manifest.type,
-      tag: rxr.manifest.tag,
-      files: rxr.manifest.files
-    };
-    const manifestData = Buffer.from(JSON.stringify(manifestJson, null, 2), "utf-8");
-    await this.storage.put(manifestKey, manifestData);
-    const archiveData = await rxr.archive.buffer();
-    await this.storage.put(archiveKey, archiveData);
-  }
-  async has(rxl) {
-    const prefix = this.buildKeyPrefix(rxl);
-    const manifestKey = `${prefix}/manifest.json`;
-    return this.storage.exists(manifestKey);
-  }
-  async remove(rxl) {
-    const prefix = this.buildKeyPrefix(rxl);
-    await this.storage.delete(prefix);
-  }
-  async list(options) {
-    const { query, limit, offset = 0 } = options ?? {};
-    const allKeys = await this.storage.list();
-    const locators = [];
-    for (const key of allKeys) {
-      if (!key.endsWith("manifest.json"))
-        continue;
-      const rxl = this.parseKeyToRXL(key);
-      if (rxl) {
-        locators.push(rxl);
-      }
-    }
-    let filtered = locators;
-    if (query) {
-      const lowerQuery = query.toLowerCase();
-      filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
-        return searchText.includes(lowerQuery);
-      });
-    }
-    let result = filtered.slice(offset);
-    if (limit !== undefined) {
-      result = result.slice(0, limit);
-    }
-    return result;
-  }
-  parseKeyToRXL(key) {
-    const dirPath = key.replace(/\/manifest\.json$/, "");
-    const parts = dirPath.split("/");
-    if (parts.length < 2) {
-      return null;
-    }
-    const tag = parts.pop();
-    const name = parts.pop();
-    const path = parts.length > 0 ? parts.join("/") : undefined;
-    let locatorStr = "";
-    if (path)
-      locatorStr += `${path}/`;
-    locatorStr += name;
-    if (tag !== "latest")
-      locatorStr += `:${tag}`;
-    try {
-      return parse2(locatorStr);
-    } catch {
-      return null;
-    }
-  }
-}
-
-class MirrorRegistry {
-  storage;
-  constructor(storage) {
-    this.storage = storage;
-  }
-  buildKeyPrefix(rxl) {
-    const registry = rxl.registry ?? "localhost";
-    const tag = rxl.tag ?? "latest";
-    let key = registry;
-    if (rxl.path) {
-      key += `/${rxl.path}`;
-    }
-    key += `/${rxl.name}/${tag}`;
-    return key;
-  }
-  async get(rxl) {
-    const prefix = this.buildKeyPrefix(rxl);
-    const manifestKey = `${prefix}/manifest.json`;
-    const archiveKey = `${prefix}/archive.tar.gz`;
-    let manifestData;
-    try {
-      manifestData = await this.storage.get(manifestKey);
-    } catch {
-      throw new RegistryError(`Resource not found in cache: ${format2(rxl)}`);
-    }
-    const manifestJson = JSON.parse(manifestData.toString("utf-8"));
-    const rxm = {
-      registry: manifestJson.registry,
-      path: manifestJson.path,
-      name: manifestJson.name,
-      type: manifestJson.type,
-      tag: manifestJson.tag,
-      files: manifestJson.files
-    };
-    const archiveData = await this.storage.get(archiveKey);
-    const rxa = wrap2(archiveData);
-    return resource2(rxm, rxa);
-  }
-  async put(rxr) {
-    const prefix = this.buildKeyPrefix(rxr.locator);
-    const manifestKey = `${prefix}/manifest.json`;
-    const archiveKey = `${prefix}/archive.tar.gz`;
-    const manifestJson = {
-      registry: rxr.manifest.registry,
-      path: rxr.manifest.path,
-      name: rxr.manifest.name,
-      type: rxr.manifest.type,
-      tag: rxr.manifest.tag,
-      files: rxr.manifest.files
-    };
-    const manifestData = Buffer.from(JSON.stringify(manifestJson, null, 2), "utf-8");
-    await this.storage.put(manifestKey, manifestData);
-    const archiveData = await rxr.archive.buffer();
-    await this.storage.put(archiveKey, archiveData);
-  }
-  async has(rxl) {
-    const prefix = this.buildKeyPrefix(rxl);
-    const manifestKey = `${prefix}/manifest.json`;
-    return this.storage.exists(manifestKey);
-  }
-  async remove(rxl) {
-    const prefix = this.buildKeyPrefix(rxl);
-    await this.storage.delete(prefix);
-  }
-  async list(options) {
-    const { query, limit, offset = 0 } = options ?? {};
-    const allKeys = await this.storage.list();
-    const locators = [];
-    for (const key of allKeys) {
-      if (!key.endsWith("manifest.json"))
-        continue;
-      const rxl = this.parseKeyToRXL(key);
-      if (rxl) {
-        locators.push(rxl);
-      }
-    }
-    let filtered = locators;
-    if (query) {
-      const lowerQuery = query.toLowerCase();
-      filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.registry ?? ""} ${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
-        return searchText.includes(lowerQuery);
-      });
-    }
-    let result = filtered.slice(offset);
-    if (limit !== undefined) {
-      result = result.slice(0, limit);
-    }
-    return result;
-  }
-  async clear(registry) {
-    if (registry) {
-      await this.storage.delete(registry);
-    } else {
-      const allKeys = await this.storage.list();
-      const registries = new Set;
-      for (const key of allKeys) {
-        const firstSlash = key.indexOf("/");
-        if (firstSlash !== -1) {
-          registries.add(key.substring(0, firstSlash));
-        } else {
-          registries.add(key);
-        }
-      }
-      for (const r of registries) {
-        await this.storage.delete(r);
-      }
-    }
-  }
-  parseKeyToRXL(key) {
-    const dirPath = key.replace(/\/manifest\.json$/, "");
-    const parts = dirPath.split("/");
-    if (parts.length < 3) {
-      return null;
-    }
-    const tag = parts.pop();
-    const name = parts.pop();
-    const registry = parts.shift();
-    const path = parts.length > 0 ? parts.join("/") : undefined;
-    let locatorStr = registry;
-    if (path)
-      locatorStr += `/${path}`;
-    locatorStr += `/${name}`;
-    if (tag !== "latest")
-      locatorStr += `:${tag}`;
-    try {
-      return parse2(locatorStr);
-    } catch {
-      return null;
-    }
-  }
-}
-
-class ResourceXError22 extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ResourceXError";
-  }
-}
-
-class DefinitionError2 extends ResourceXError22 {
-  constructor(message) {
-    super(message);
-    this.name = "DefinitionError";
-  }
-}
-function define2(input) {
-  if (input === null || typeof input !== "object") {
-    throw new DefinitionError2("definition must be an object");
-  }
-  const obj = input;
-  if (!obj.name || typeof obj.name !== "string") {
-    throw new DefinitionError2("name is required");
-  }
-  if (!obj.type || typeof obj.type !== "string") {
-    throw new DefinitionError2("type is required");
-  }
-  const tagValue = obj.tag ?? obj.version;
-  if (tagValue !== undefined && typeof tagValue !== "string") {
-    throw new DefinitionError2("tag must be a string");
-  }
-  const rxd = {
-    ...obj,
-    name: obj.name,
-    type: obj.type,
-    tag: typeof tagValue === "string" ? tagValue : undefined,
-    registry: typeof obj.registry === "string" ? obj.registry : undefined,
-    path: typeof obj.path === "string" ? obj.path : undefined,
-    description: typeof obj.description === "string" ? obj.description : undefined,
-    author: typeof obj.author === "string" ? obj.author : undefined,
-    license: typeof obj.license === "string" ? obj.license : undefined,
-    keywords: Array.isArray(obj.keywords) ? obj.keywords : undefined,
-    repository: typeof obj.repository === "string" ? obj.repository : undefined
-  };
-  return rxd;
-}
-function manifest2(rxd) {
-  return {
-    registry: rxd.registry,
-    path: rxd.path,
-    name: rxd.name,
-    type: rxd.type,
-    tag: rxd.tag ?? "latest"
-  };
-}
-var BLOCK_SIZE22 = 512;
-var BLOCK_SIZE_MASK2 = 511;
-var DEFAULT_FILE_MODE2 = 420;
-var DEFAULT_DIR_MODE2 = 493;
-var USTAR_NAME_OFFSET2 = 0;
-var USTAR_NAME_SIZE2 = 100;
-var USTAR_MODE_OFFSET2 = 100;
-var USTAR_MODE_SIZE2 = 8;
-var USTAR_UID_OFFSET2 = 108;
-var USTAR_UID_SIZE2 = 8;
-var USTAR_GID_OFFSET2 = 116;
-var USTAR_GID_SIZE2 = 8;
-var USTAR_SIZE_OFFSET2 = 124;
-var USTAR_SIZE_SIZE2 = 12;
-var USTAR_MTIME_OFFSET2 = 136;
-var USTAR_MTIME_SIZE2 = 12;
-var USTAR_CHECKSUM_OFFSET2 = 148;
-var USTAR_CHECKSUM_SIZE2 = 8;
-var USTAR_TYPEFLAG_OFFSET2 = 156;
-var USTAR_TYPEFLAG_SIZE2 = 1;
-var USTAR_LINKNAME_OFFSET2 = 157;
-var USTAR_LINKNAME_SIZE2 = 100;
-var USTAR_MAGIC_OFFSET2 = 257;
-var USTAR_MAGIC_SIZE2 = 6;
-var USTAR_VERSION_OFFSET2 = 263;
-var USTAR_VERSION_SIZE2 = 2;
-var USTAR_UNAME_OFFSET2 = 265;
-var USTAR_UNAME_SIZE2 = 32;
-var USTAR_GNAME_OFFSET2 = 297;
-var USTAR_GNAME_SIZE2 = 32;
-var USTAR_PREFIX_OFFSET2 = 345;
-var USTAR_PREFIX_SIZE2 = 155;
-var USTAR_VERSION2 = "00";
-var USTAR_MAX_UID_GID2 = 2097151;
-var USTAR_MAX_SIZE2 = 8589934591;
-var FILE2 = "file";
-var LINK2 = "link";
-var SYMLINK2 = "symlink";
-var DIRECTORY2 = "directory";
-var TYPEFLAG2 = {
-  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 ZERO_BLOCK22 = new Uint8Array(BLOCK_SIZE22);
-var EMPTY22 = new Uint8Array(0);
-var encoder22 = new TextEncoder;
-var decoder22 = new TextDecoder;
-function writeString2(view, offset, size, value) {
-  if (value)
-    encoder22.encodeInto(value, view.subarray(offset, offset + size));
-}
-function writeOctal2(view, offset, size, value) {
-  if (value === undefined)
-    return;
-  const octalString = value.toString(8).padStart(size - 1, "0");
-  encoder22.encodeInto(octalString, view.subarray(offset, offset + size - 1));
-}
-var isBodyless2 = (header) => header.type === DIRECTORY2 || header.type === SYMLINK2 || header.type === LINK2;
-async function normalizeBody2(body) {
-  if (body === null || body === undefined)
-    return EMPTY22;
-  if (body instanceof Uint8Array)
-    return body;
-  if (typeof body === "string")
-    return encoder22.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.");
-}
-var CHECKSUM_SPACE2 = 32;
-var ASCII_ZERO2 = 48;
-function writeChecksum2(block) {
-  block.fill(CHECKSUM_SPACE2, USTAR_CHECKSUM_OFFSET2, USTAR_CHECKSUM_OFFSET2 + USTAR_CHECKSUM_SIZE2);
-  let checksum = 0;
-  for (const byte of block)
-    checksum += byte;
-  for (let i = USTAR_CHECKSUM_OFFSET2 + 6 - 1;i >= USTAR_CHECKSUM_OFFSET2; i--) {
-    block[i] = (checksum & 7) + ASCII_ZERO2;
-    checksum >>= 3;
-  }
-  block[USTAR_CHECKSUM_OFFSET2 + 6] = 0;
-  block[USTAR_CHECKSUM_OFFSET2 + 7] = CHECKSUM_SPACE2;
-}
-function generatePax2(header) {
-  const paxRecords = {};
-  if (header.name.length > USTAR_NAME_SIZE2) {
-    if (findUstarSplit2(header.name) === null)
-      paxRecords.path = header.name;
-  }
-  if (header.linkname && header.linkname.length > USTAR_NAME_SIZE2)
-    paxRecords.linkpath = header.linkname;
-  if (header.uname && header.uname.length > USTAR_UNAME_SIZE2)
-    paxRecords.uname = header.uname;
-  if (header.gname && header.gname.length > USTAR_GNAME_SIZE2)
-    paxRecords.gname = header.gname;
-  if (header.uid != null && header.uid > USTAR_MAX_UID_GID2)
-    paxRecords.uid = String(header.uid);
-  if (header.gid != null && header.gid > USTAR_MAX_UID_GID2)
-    paxRecords.gid = String(header.gid);
-  if (header.size != null && header.size > USTAR_MAX_SIZE2)
-    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 = encoder22.encode(paxEntries.map(([key, value]) => {
-    const record = `${key}=${value}
-`;
-    const partLength = encoder22.encode(record).length + 1;
-    let totalLength = partLength + String(partLength).length;
-    totalLength = partLength + String(totalLength).length;
-    return `${totalLength} ${record}`;
-  }).join(""));
-  return {
-    paxHeader: createTarHeader2({
-      name: decoder22.decode(encoder22.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 findUstarSplit2(path) {
-  if (path.length <= USTAR_NAME_SIZE2)
-    return null;
-  const minSlashIndex = path.length - USTAR_NAME_SIZE2 - 1;
-  const slashIndex = path.lastIndexOf("/", USTAR_PREFIX_SIZE2);
-  if (slashIndex > 0 && slashIndex >= minSlashIndex)
-    return {
-      prefix: path.slice(0, slashIndex),
-      name: path.slice(slashIndex + 1)
-    };
-  return null;
-}
-function createTarHeader2(header) {
-  const view = new Uint8Array(BLOCK_SIZE22);
-  const size = isBodyless2(header) ? 0 : header.size ?? 0;
-  let name = header.name;
-  let prefix = "";
-  if (!header.pax?.path) {
-    const split = findUstarSplit2(name);
-    if (split) {
-      name = split.name;
-      prefix = split.prefix;
-    }
-  }
-  writeString2(view, USTAR_NAME_OFFSET2, USTAR_NAME_SIZE2, name);
-  writeOctal2(view, USTAR_MODE_OFFSET2, USTAR_MODE_SIZE2, header.mode ?? (header.type === DIRECTORY2 ? DEFAULT_DIR_MODE2 : DEFAULT_FILE_MODE2));
-  writeOctal2(view, USTAR_UID_OFFSET2, USTAR_UID_SIZE2, header.uid ?? 0);
-  writeOctal2(view, USTAR_GID_OFFSET2, USTAR_GID_SIZE2, header.gid ?? 0);
-  writeOctal2(view, USTAR_SIZE_OFFSET2, USTAR_SIZE_SIZE2, size);
-  writeOctal2(view, USTAR_MTIME_OFFSET2, USTAR_MTIME_SIZE2, Math.floor((header.mtime?.getTime() ?? Date.now()) / 1000));
-  writeString2(view, USTAR_TYPEFLAG_OFFSET2, USTAR_TYPEFLAG_SIZE2, TYPEFLAG2[header.type ?? FILE2]);
-  writeString2(view, USTAR_LINKNAME_OFFSET2, USTAR_LINKNAME_SIZE2, header.linkname);
-  writeString2(view, USTAR_MAGIC_OFFSET2, USTAR_MAGIC_SIZE2, "ustar\x00");
-  writeString2(view, USTAR_VERSION_OFFSET2, USTAR_VERSION_SIZE2, USTAR_VERSION2);
-  writeString2(view, USTAR_UNAME_OFFSET2, USTAR_UNAME_SIZE2, header.uname);
-  writeString2(view, USTAR_GNAME_OFFSET2, USTAR_GNAME_SIZE2, header.gname);
-  writeString2(view, USTAR_PREFIX_OFFSET2, USTAR_PREFIX_SIZE2, prefix);
-  writeChecksum2(view);
-  return view;
-}
-function getHeaderBlocks2(header) {
-  const base = createTarHeader2(header);
-  const pax = generatePax2(header);
-  if (!pax)
-    return [base];
-  const paxPadding = -pax.paxBody.length & BLOCK_SIZE_MASK2;
-  const paddingBlocks = paxPadding > 0 ? [ZERO_BLOCK22.subarray(0, paxPadding)] : [];
-  return [
-    pax.paxHeader,
-    pax.paxBody,
-    ...paddingBlocks,
-    base
-  ];
-}
-var EOF_BUFFER22 = new Uint8Array(BLOCK_SIZE22 * 2);
-function createTarPacker3(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 = isBodyless2(header) ? 0 : header.size ?? 0;
-        const headerBlocks = getHeaderBlocks2({
-          ...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_MASK2;
-        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_BUFFER22);
-        finalized = true;
-        if (onFinalize)
-          onFinalize();
-      } catch (error) {
-        onError(error);
-      }
-    }
-  };
-}
-function createTarPacker22() {
-  let streamController;
-  let packer;
-  return {
-    readable: new ReadableStream({ start(controller) {
-      streamController = controller;
-      packer = createTarPacker3(controller.enqueue.bind(controller), controller.error.bind(controller), controller.close.bind(controller));
-    } }),
-    controller: {
-      add(header) {
-        const bodyless = isBodyless2(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 streamToBuffer2(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();
-  }
-}
-async function packTar2(entries) {
-  const { readable, controller } = createTarPacker22();
-  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 normalizeBody2(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 streamToBuffer2(readable));
-}
-var gzipAsync22 = promisify32(gzip22);
-
-class RXAImpl3 {
-  _buffer;
-  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 function archive2(files) {
-  const entries = Object.entries(files).map(([name, content]) => {
-    return {
-      header: { name, size: content.length, type: "file" },
-      body: new Uint8Array(content)
-    };
-  });
-  const tarBuffer = await packTar2(entries);
-  const gzipBuffer = await gzipAsync22(Buffer.from(tarBuffer));
-  return new RXAImpl3(gzipBuffer);
-}
-function locate22(rxm) {
-  return {
-    registry: rxm.registry,
-    path: rxm.path,
-    name: rxm.name,
-    tag: rxm.tag
-  };
-}
-function resource22(rxm, rxa) {
-  const rxl = locate22(rxm);
-  return {
-    locator: rxl,
-    manifest: rxm,
-    archive: rxa
-  };
-}
-var gunzipAsync22 = promisify222(gunzip22);
-
-class FolderLoader {
-  async canLoad(source) {
-    try {
-      const stats = await stat2(source);
-      if (!stats.isDirectory()) {
-        return false;
-      }
-      const manifestPath = join3(source, "resource.json");
-      const manifestStats = await stat2(manifestPath);
-      return manifestStats.isFile();
-    } catch {
-      return false;
-    }
-  }
-  async load(folderPath) {
-    const resourceJsonPath = join3(folderPath, "resource.json");
-    let resourceJson;
-    try {
-      resourceJson = await readFile3(resourceJsonPath, "utf-8");
-    } catch (error) {
-      throw new ResourceXError22(`Failed to read resource.json: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    let json;
-    try {
-      json = JSON.parse(resourceJson);
-    } catch (error) {
-      throw new ResourceXError22(`Invalid JSON in resource.json: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    const rxd = define2(json);
-    const files = await this.readFolderFiles(folderPath);
-    if (Object.keys(files).length === 0) {
-      throw new ResourceXError22("No content files found in resource folder");
-    }
-    const rxm = manifest2(rxd);
-    const rxa = await archive2(files);
-    return resource22(rxm, rxa);
-  }
-  async readFolderFiles(folderPath, basePath = folderPath) {
-    const files = {};
-    const entries = await readdir3(folderPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join3(folderPath, entry.name);
-      const relativePath = relative(basePath, fullPath);
-      if (relativePath === "resource.json") {
-        continue;
-      }
-      if (entry.isFile()) {
-        files[relativePath] = await readFile3(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 ResourceXError22(`Cannot load resource from: ${source}`);
-  }
-  return loader.load(source);
-}
-
-class LinkedRegistry {
-  basePath;
-  constructor(basePath) {
-    this.basePath = basePath;
-  }
-  buildLinkPath(rxl) {
-    const registry = rxl.registry ?? "localhost";
-    const tag = rxl.tag ?? "latest";
-    let linkPath = join22(this.basePath, registry);
-    if (rxl.path) {
-      linkPath = join22(linkPath, rxl.path);
-    }
-    return join22(linkPath, rxl.name, tag);
-  }
-  async isSymlink(path) {
-    try {
-      const stats = await lstat(path);
-      return stats.isSymbolicLink();
-    } catch {
-      return false;
-    }
-  }
-  async get(rxl) {
-    const linkPath = this.buildLinkPath(rxl);
-    if (!await this.isSymlink(linkPath)) {
-      throw new RegistryError(`Linked resource not found: ${format2(rxl)}`);
-    }
-    const targetPath = await readlink(linkPath);
-    return loadResource(targetPath);
-  }
-  async put(_rxr) {
-    throw new RegistryError("LinkedRegistry does not support put(). Use link() instead.");
-  }
-  async has(rxl) {
-    const linkPath = this.buildLinkPath(rxl);
-    return this.isSymlink(linkPath);
-  }
-  async remove(rxl) {
-    const linkPath = this.buildLinkPath(rxl);
-    if (await this.isSymlink(linkPath)) {
-      await rm3(linkPath);
-    }
-  }
-  async list(options) {
-    const { query, limit, offset = 0 } = options ?? {};
-    const locators = [];
-    try {
-      await this.scanSymlinks(this.basePath, "", locators);
-    } catch {
-      return [];
-    }
-    let filtered = locators;
-    if (query) {
-      const lowerQuery = query.toLowerCase();
-      filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.registry ?? ""} ${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
-        return searchText.includes(lowerQuery);
-      });
-    }
-    let result = filtered.slice(offset);
-    if (limit !== undefined) {
-      result = result.slice(0, limit);
-    }
-    return result;
-  }
-  async link(devPath) {
-    const rxr = await loadResource(devPath);
-    const linkPath = this.buildLinkPath(rxr.locator);
-    try {
-      const stats = await lstat(linkPath);
-      if (stats.isSymbolicLink() || stats.isDirectory()) {
-        await rm3(linkPath, { recursive: true });
-      }
-    } catch {}
-    const parentPath = join22(linkPath, "..");
-    await mkdir3(parentPath, { recursive: true });
-    const absolutePath = resolvePath(devPath);
-    await symlink(absolutePath, linkPath);
-    return rxr.locator;
-  }
-  async unlink(rxl) {
-    return this.remove(rxl);
-  }
-  async scanSymlinks(dirPath, relativePath, locators) {
-    let entries;
-    try {
-      entries = await readdir22(dirPath);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = join22(dirPath, entry);
-      const relPath = relativePath ? `${relativePath}/${entry}` : entry;
-      try {
-        const stats = await lstat(fullPath);
-        if (stats.isSymbolicLink()) {
-          const rxl = this.parsePathToRXL(relPath);
-          if (rxl) {
-            locators.push(rxl);
-          }
-        } else if (stats.isDirectory()) {
-          await this.scanSymlinks(fullPath, relPath, locators);
-        }
-      } catch {}
-    }
-  }
-  parsePathToRXL(relPath) {
-    const parts = relPath.split("/");
-    if (parts.length < 3) {
-      return null;
-    }
-    const tag = parts.pop();
-    const name = parts.pop();
-    const registry = parts.shift();
-    const path = parts.length > 0 ? parts.join("/") : undefined;
-    let locatorStr = registry;
-    if (path)
-      locatorStr += `/${path}`;
-    locatorStr += `/${name}`;
-    if (tag !== "latest")
-      locatorStr += `:${tag}`;
-    try {
-      return parse2(locatorStr);
-    } catch {
-      return null;
-    }
-  }
-}
-
-class RegistryAccessChain {
-  accessors;
-  memCache = new Map;
-  useMemCache;
-  constructor(accessors, options) {
-    this.accessors = accessors;
-    this.useMemCache = options?.memCache ?? false;
-  }
-  async get(rxl) {
-    const key = format2(rxl);
-    if (this.useMemCache && this.memCache.has(key)) {
-      return this.memCache.get(key);
-    }
-    for (const accessor of this.accessors) {
-      if (await accessor.canHandle(rxl)) {
-        const rxr = await accessor.get(rxl);
-        if (this.useMemCache && accessor.name !== "linked") {
-          this.memCache.set(key, rxr);
-        }
-        return rxr;
-      }
-    }
-    throw new RegistryError(`Resource not found: ${key}`);
-  }
-  async has(rxl) {
-    const key = format2(rxl);
-    if (this.useMemCache && this.memCache.has(key)) {
-      return true;
-    }
-    for (const accessor of this.accessors) {
-      if (await accessor.canHandle(rxl)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  clearCache() {
-    this.memCache.clear();
-  }
-  invalidate(rxl) {
-    this.memCache.delete(format2(rxl));
-  }
-}
-
-class LinkedAccessor {
-  registry;
-  name = "linked";
-  constructor(registry) {
-    this.registry = registry;
-  }
-  async canHandle(rxl) {
-    return this.registry.has(rxl);
-  }
-  async get(rxl) {
-    return this.registry.get(rxl);
-  }
-}
-
-class LocalAccessor {
-  registry;
-  name = "local";
-  constructor(registry) {
-    this.registry = registry;
-  }
-  async canHandle(rxl) {
-    if (rxl.registry) {
-      return false;
-    }
-    return this.registry.has(rxl);
-  }
-  async get(rxl) {
-    return this.registry.get(rxl);
-  }
-}
-
-class CacheAccessor {
-  registry;
-  name = "cache";
-  constructor(registry) {
-    this.registry = registry;
-  }
-  async canHandle(rxl) {
-    if (!rxl.registry) {
-      return false;
-    }
-    return this.registry.has(rxl);
-  }
-  async get(rxl) {
-    return this.registry.get(rxl);
-  }
-}
-
-class RemoteAccessor {
-  fetcher;
-  cache;
-  name = "remote";
-  constructor(fetcher, cache) {
-    this.fetcher = fetcher;
-    this.cache = cache;
-  }
-  async canHandle(rxl) {
-    return !!rxl.registry;
-  }
-  async get(rxl) {
-    const rxr = await this.fetcher.fetch(rxl);
-    await this.cache.put(rxr);
-    return rxr;
-  }
-}
-
-// src/transport/rxr.ts
-var DEFAULT_BASE_PATH = `${homedir()}/.resourcex`;
-
-class InternalRegistryAccess {
-  local;
-  cache;
-  linked;
-  constructor(basePath = DEFAULT_BASE_PATH) {
-    const localStorage = new FileSystemStorage(join4(basePath, "local"));
-    const cacheStorage = new FileSystemStorage(join4(basePath, "cache"));
-    this.local = new LocalRegistry(localStorage);
-    this.cache = new MirrorRegistry(cacheStorage);
-    this.linked = new LinkedRegistry(join4(basePath, "linked"));
-  }
-  async get(locator) {
-    const rxl = parse(locator);
-    if (await this.linked.has(rxl)) {
-      return this.linked.get(rxl);
-    }
-    if (!rxl.registry && await this.local.has(rxl)) {
-      return this.local.get(rxl);
-    }
-    if (rxl.registry && await this.cache.has(rxl)) {
-      return this.cache.get(rxl);
-    }
-    throw new Error(`Resource not found: ${locator}`);
-  }
-}
-var defaultRegistry = null;
-
-class RxrTransport {
-  basePath;
-  name = "rxr";
-  constructor(basePath) {
-    this.basePath = basePath;
-  }
-  async get(location, _params) {
-    const { rxl, internalPath } = this.parseLocation(location);
-    const registry = this.getRegistry();
-    const rxr = await registry.get(rxl);
-    const files = await extract(rxr.archive);
-    const file = files[internalPath];
-    if (!file) {
-      throw new TransportError(`File not found in resource: ${internalPath}`, this.name);
-    }
-    return {
-      content: file,
-      metadata: { type: "file", size: file.length }
-    };
-  }
-  async set(_location, _content, _params) {
-    throw new TransportError("RXR transport is read-only", this.name);
-  }
-  async exists(location) {
-    try {
-      const { rxl, internalPath } = this.parseLocation(location);
-      const registry = this.getRegistry();
-      const rxr = await registry.get(rxl);
-      const files = await extract(rxr.archive);
-      return internalPath in files;
-    } catch {
-      return false;
-    }
-  }
-  async delete(_location) {
-    throw new TransportError("RXR transport is read-only", this.name);
-  }
-  getRegistry() {
-    if (this.basePath) {
-      return new InternalRegistryAccess(this.basePath);
-    }
-    if (!defaultRegistry) {
-      defaultRegistry = new InternalRegistryAccess;
-    }
-    return defaultRegistry;
-  }
-  parseLocation(location) {
-    const atIndex = location.indexOf("@");
-    if (atIndex === -1) {
-      throw new TransportError(`Invalid RXR location (missing @version): ${location}`, this.name);
-    }
-    const slashAfterVersion = location.indexOf("/", atIndex);
-    if (slashAfterVersion === -1) {
-      throw new TransportError(`Invalid RXR location (missing internal path): ${location}`, this.name);
-    }
-    return {
-      rxl: location.slice(0, slashAfterVersion),
-      internalPath: location.slice(slashAfterVersion + 1)
-    };
-  }
-}
-function clearRegistryCache() {
-  defaultRegistry = null;
-}
-
-// src/arp.ts
-function createARP2(config) {
-  const arp = createARP(config);
-  const hasRxrTransport = config?.transports?.some((t) => t.name === "rxr");
-  if (!hasRxrTransport) {
-    arp.registerTransport(new RxrTransport);
-  }
-  return arp;
-}
+var VERSION = "2.5.7";
 export {
   textSemantic,
   httpsTransport,
   httpTransport,
   fileTransport,
-  createARP2 as createARP,
-  clearRegistryCache,
+  createARP,
   binarySemantic,
   VERSION,
   TransportError,
   TextSemanticHandler,
   SemanticError,
-  RxrTransport,
   ParseError,
   HttpTransportHandler,
   FileTransportHandler,
@@ -3171,4 +546,4 @@ export {
   ARP
 };
 
-//# debugId=53BD99671BBE01D264756E2164756E21
+//# debugId=962C017218F1C6E664756E2164756E21