@resourcexjs/arp 2.0.0 → 2.1.0

package/dist/index.js

@@ -88,6 +88,20 @@ class ARL {
     }
     await transport.delete(this.location);
   }
+  async list(options) {
+    const transport = this.resolver.getTransportHandler(this.transport);
+    if (!transport.list) {
+      throw new TransportError(`Transport "${transport.name}" does not support list operation`, this.transport);
+    }
+    return transport.list(this.location, options);
+  }
+  async mkdir() {
+    const transport = this.resolver.getTransportHandler(this.transport);
+    if (!transport.mkdir) {
+      throw new TransportError(`Transport "${transport.name}" does not support mkdir operation`, this.transport);
+    }
+    await transport.mkdir(this.location);
+  }
   toString() {
     return `arp:${this.semantic}:${this.transport}://${this.location}`;
   }
@@ -207,6 +221,37 @@ class FileTransportHandler {
       });
     }
   }
+  async list(location, options) {
+    const dirPath = this.resolvePath(location);
+    try {
+      let entries;
+      if (options?.recursive) {
+        entries = await this.listRecursive(dirPath, dirPath);
+      } else {
+        entries = await readdir(dirPath);
+      }
+      if (options?.pattern) {
+        entries = this.filterByPattern(entries, options.pattern);
+      }
+      return entries;
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File list error: ${err.code} - ${dirPath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async mkdir(location) {
+    const dirPath = this.resolvePath(location);
+    try {
+      await mkdir(dirPath, { recursive: true });
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File mkdir error: ${err.code} - ${dirPath}`, this.name, {
+        cause: err
+      });
+    }
+  }
 }
 var fileTransport = new FileTransportHandler;
 // src/transport/http.ts
@@ -274,2097 +319,6 @@ class HttpTransportHandler {
 }
 var httpsTransport = new HttpTransportHandler("https");
 var httpTransport = new HttpTransportHandler("http");
-// ../registry/dist/index.js
-import { gzip, gunzip } from "node:zlib";
-import { promisify } from "node:util";
-import { homedir } from "node:os";
-import { join as join2 } from "node:path";
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, rm as rm2, stat as stat2, readdir as readdir2 } from "node:fs/promises";
-import { gzip as gzip2, gunzip as gunzip2 } from "node:zlib";
-import { promisify as promisify2 } from "node:util";
-import { homedir as homedir2 } from "node:os";
-import { join as join22 } from "node:path";
-import { readFile as readFile22, stat as stat22, readdir as readdir22, mkdir as mkdir22 } from "node:fs/promises";
-import { execSync } from "node:child_process";
-function isRemoteConfig(config) {
-  return config !== undefined && "endpoint" in config;
-}
-function isGitConfig(config) {
-  return config !== undefined && "type" in config && config.type === "git";
-}
-
-class ResourceXError extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ResourceXError";
-  }
-}
-
-class ManifestError extends ResourceXError {
-  constructor(message) {
-    super(message);
-    this.name = "ManifestError";
-  }
-}
-
-class RXLImpl {
-  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 + "/";
-      }
-    }
-    result += this.name;
-    if (this.type) {
-      result += "." + this.type;
-    }
-    if (this.version) {
-      result += "@" + this.version;
-    }
-    return result;
-  }
-}
-function isDomain(str) {
-  if (str === "localhost")
-    return true;
-  return str.includes(".");
-}
-function parseRXL(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);
-  }
-  const segments = remaining.split("/");
-  if (segments.length > 1 && isDomain(segments[0])) {
-    domain = segments[0];
-    const lastSegment = segments[segments.length - 1];
-    if (segments.length > 2) {
-      path = segments.slice(1, -1).join("/");
-    }
-    remaining = lastSegment;
-  } else {
-    remaining = segments.join("/");
-  }
-  const dotIndex = remaining.lastIndexOf(".");
-  if (dotIndex !== -1) {
-    type = remaining.slice(dotIndex + 1);
-    name = remaining.slice(0, dotIndex);
-  } else {
-    name = remaining;
-  }
-  return new RXLImpl({ domain, path, name, type, version });
-}
-
-class RXMImpl {
-  domain;
-  path;
-  name;
-  type;
-  version;
-  constructor(data) {
-    this.domain = data.domain;
-    this.path = data.path;
-    this.name = data.name;
-    this.type = data.type;
-    this.version = data.version;
-  }
-  toLocator() {
-    let result = this.domain + "/";
-    if (this.path) {
-      result += this.path + "/";
-    }
-    result += this.name;
-    result += "." + this.type;
-    result += "@" + this.version;
-    return result;
-  }
-  toJSON() {
-    const json = {
-      domain: this.domain,
-      name: this.name,
-      type: this.type,
-      version: this.version
-    };
-    if (this.path !== undefined) {
-      json.path = this.path;
-    }
-    return json;
-  }
-}
-function createRXM(data) {
-  if (!data.domain) {
-    throw new ManifestError("domain is required");
-  }
-  if (!data.name) {
-    throw new ManifestError("name is required");
-  }
-  if (!data.type) {
-    throw new ManifestError("type is required");
-  }
-  if (!data.version) {
-    throw new ManifestError("version is required");
-  }
-  return new RXMImpl({
-    domain: data.domain,
-    path: data.path,
-    name: data.name,
-    type: data.type,
-    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 RegistryError extends ResourceXError {
-  constructor(message) {
-    super(message);
-    this.name = "RegistryError";
-  }
-}
-
-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 + "/";
-      }
-    }
-    result += this.name;
-    if (this.type) {
-      result += "." + this.type;
-    }
-    if (this.version) {
-      result += "@" + this.version;
-    }
-    return result;
-  }
-}
-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);
-  }
-  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("/");
-    }
-    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 result;
-  } finally {
-    reader.releaseLock();
-  }
-}
-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;
-}
-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(new Uint8Array(buffer));
-        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));
-      }
-    }
-    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";
-  }
-}
-var textSerializer = {
-  async serialize(rxr) {
-    return rxr.content.buffer();
-  },
-  async deserialize(data, manifest) {
-    return {
-      locator: parseRXL2(manifest.toLocator()),
-      manifest,
-      content: await createRXC({ archive: data })
-    };
-  }
-};
-var textResolver = {
-  schema: undefined,
-  async resolve(rxr) {
-    return {
-      resource: rxr,
-      schema: undefined,
-      execute: async () => {
-        const buffer = await rxr.content.file("content");
-        return buffer.toString("utf-8");
-      }
-    };
-  }
-};
-var textType = {
-  name: "text",
-  aliases: ["txt", "plaintext"],
-  description: "Plain text content",
-  serializer: textSerializer,
-  resolver: textResolver
-};
-var jsonSerializer = {
-  async serialize(rxr) {
-    return rxr.content.buffer();
-  },
-  async deserialize(data, manifest) {
-    return {
-      locator: parseRXL2(manifest.toLocator()),
-      manifest,
-      content: await createRXC({ archive: data })
-    };
-  }
-};
-var jsonResolver = {
-  schema: undefined,
-  async resolve(rxr) {
-    return {
-      resource: rxr,
-      schema: undefined,
-      execute: async () => {
-        const buffer = await rxr.content.file("content");
-        return JSON.parse(buffer.toString("utf-8"));
-      }
-    };
-  }
-};
-var jsonType = {
-  name: "json",
-  aliases: ["config", "manifest"],
-  description: "JSON content",
-  serializer: jsonSerializer,
-  resolver: jsonResolver
-};
-var binarySerializer = {
-  async serialize(rxr) {
-    return rxr.content.buffer();
-  },
-  async deserialize(data, manifest) {
-    return {
-      locator: parseRXL2(manifest.toLocator()),
-      manifest,
-      content: await createRXC({ archive: data })
-    };
-  }
-};
-var binaryResolver = {
-  schema: undefined,
-  async resolve(rxr) {
-    return {
-      resource: rxr,
-      schema: undefined,
-      execute: async () => {
-        return rxr.content.file("content");
-      }
-    };
-  }
-};
-var binaryType = {
-  name: "binary",
-  aliases: ["bin", "blob", "raw"],
-  description: "Binary content",
-  serializer: binarySerializer,
-  resolver: binaryResolver
-};
-var builtinTypes = [textType, jsonType, binaryType];
-
-class TypeHandlerChain {
-  handlers = new Map;
-  constructor() {
-    for (const type of builtinTypes) {
-      this.registerBuiltin(type);
-    }
-  }
-  static create() {
-    return new TypeHandlerChain;
-  }
-  registerBuiltin(type) {
-    this.handlers.set(type.name, type);
-    if (type.aliases) {
-      for (const alias of type.aliases) {
-        this.handlers.set(alias, 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) {
-    return this.handlers.has(typeName);
-  }
-  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);
-    if (!handler) {
-      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
-    }
-    return handler.serializer.serialize(rxr);
-  }
-  async deserialize(data, manifest) {
-    const typeName = manifest.type;
-    const handler = this.handlers.get(typeName);
-    if (!handler) {
-      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
-    }
-    return handler.serializer.deserialize(data, manifest);
-  }
-  async resolve(rxr) {
-    const typeName = rxr.manifest.type;
-    const handler = this.handlers.get(typeName);
-    if (!handler) {
-      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
-    }
-    return handler.resolver.resolve(rxr);
-  }
-  clearExtensions() {
-    this.handlers.clear();
-    for (const type of builtinTypes) {
-      this.registerBuiltin(type);
-    }
-  }
-}
-var DEFAULT_PATH = `${homedir()}/.resourcex`;
-
-class LocalRegistry {
-  basePath;
-  typeHandler;
-  constructor(config) {
-    this.basePath = config?.path ?? DEFAULT_PATH;
-    this.typeHandler = TypeHandlerChain.create();
-    if (config?.types) {
-      for (const type of config.types) {
-        this.typeHandler.register(type);
-      }
-    }
-  }
-  supportType(type) {
-    this.typeHandler.register(type);
-  }
-  buildPath(locator, area) {
-    const rxl = typeof locator === "string" ? parseRXL(locator) : locator;
-    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    const version = rxl.version ?? "latest";
-    if (area === "local") {
-      return join2(this.basePath, "local", resourceName, version);
-    } else {
-      const domain = rxl.domain ?? "localhost";
-      let path = join2(this.basePath, "cache", domain);
-      if (rxl.path) {
-        path = join2(path, rxl.path);
-      }
-      return join2(path, resourceName, version);
-    }
-  }
-  isLocalOnlyLocator(locator) {
-    const rxl = typeof locator === "string" ? parseRXL(locator) : locator;
-    return !rxl.domain || rxl.domain === "localhost";
-  }
-  async existsAt(resourcePath) {
-    const manifestPath = join2(resourcePath, "manifest.json");
-    try {
-      await stat2(manifestPath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async findArea(locator) {
-    const localPath = this.buildPath(locator, "local");
-    if (await this.existsAt(localPath)) {
-      return "local";
-    }
-    const cachePath = this.buildPath(locator, "cache");
-    if (await this.existsAt(cachePath)) {
-      return "cache";
-    }
-    return null;
-  }
-  async loadFrom(resourcePath) {
-    const manifestPath = join2(resourcePath, "manifest.json");
-    const manifestContent = await readFile2(manifestPath, "utf-8");
-    const manifestData = JSON.parse(manifestContent);
-    const manifest = createRXM(manifestData);
-    const contentPath = join2(resourcePath, "content.tar.gz");
-    const data = await readFile2(contentPath);
-    return this.typeHandler.deserialize(data, manifest);
-  }
-  async pull(_locator, _options) {
-    throw new RegistryError("Pull not implemented yet - see issue #018");
-  }
-  async publish(_resource, _options) {
-    throw new RegistryError("Publish not implemented yet - see issue #018");
-  }
-  async link(resource) {
-    const locator = resource.manifest.toLocator();
-    const resourcePath = this.buildPath(locator, "local");
-    await mkdir2(resourcePath, { recursive: true });
-    const manifestPath = join2(resourcePath, "manifest.json");
-    await writeFile2(manifestPath, JSON.stringify(resource.manifest.toJSON(), null, 2), "utf-8");
-    const contentPath = join2(resourcePath, "content.tar.gz");
-    const serialized = await this.typeHandler.serialize(resource);
-    await writeFile2(contentPath, serialized);
-  }
-  async get(locator) {
-    const area = await this.findArea(locator);
-    if (!area) {
-      throw new RegistryError(`Resource not found: ${locator}`);
-    }
-    const resourcePath = this.buildPath(locator, area);
-    return this.loadFrom(resourcePath);
-  }
-  async resolve(locator) {
-    const rxr = await this.get(locator);
-    return this.typeHandler.resolve(rxr);
-  }
-  async exists(locator) {
-    const area = await this.findArea(locator);
-    return area !== null;
-  }
-  async delete(locator) {
-    const isLocal = this.isLocalOnlyLocator(locator);
-    if (isLocal) {
-      const localPath = this.buildPath(locator, "local");
-      if (await this.existsAt(localPath)) {
-        await rm2(localPath, { recursive: true, force: true });
-      }
-    } else {
-      const cachePath = this.buildPath(locator, "cache");
-      if (await this.existsAt(cachePath)) {
-        await rm2(cachePath, { recursive: true, force: true });
-      }
-    }
-  }
-  async search(options) {
-    const { query, limit, offset = 0 } = options ?? {};
-    const locators = [];
-    const localDir = join2(this.basePath, "local");
-    try {
-      const localEntries = await this.listRecursive(localDir);
-      for (const entry of localEntries) {
-        if (!entry.endsWith("manifest.json"))
-          continue;
-        const relativePath = entry.slice(localDir.length + 1);
-        const rxl = this.parseLocalEntry(relativePath);
-        if (rxl)
-          locators.push(rxl);
-      }
-    } catch {}
-    const cacheDir = join2(this.basePath, "cache");
-    try {
-      const cacheEntries = await this.listRecursive(cacheDir);
-      for (const entry of cacheEntries) {
-        if (!entry.endsWith("manifest.json"))
-          continue;
-        const relativePath = entry.slice(cacheDir.length + 1);
-        const rxl = this.parseCacheEntry(relativePath);
-        if (rxl)
-          locators.push(rxl);
-      }
-    } catch {}
-    let filtered = locators;
-    if (query) {
-      const lowerQuery = query.toLowerCase();
-      filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
-        return searchText.includes(lowerQuery);
-      });
-    }
-    let result = filtered.slice(offset);
-    if (limit !== undefined) {
-      result = result.slice(0, limit);
-    }
-    return result;
-  }
-  async listRecursive(dir) {
-    const results = [];
-    try {
-      const entries = await readdir2(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = join2(dir, entry.name);
-        if (entry.isDirectory()) {
-          const subEntries = await this.listRecursive(fullPath);
-          results.push(...subEntries);
-        } else {
-          results.push(fullPath);
-        }
-      }
-    } catch {}
-    return results;
-  }
-  parseLocalEntry(entry) {
-    const dirPath = entry.replace(/[/\\]manifest\.json$/, "");
-    const parts = dirPath.split(/[/\\]/);
-    if (parts.length < 2) {
-      return null;
-    }
-    const version = parts.pop();
-    const nameTypePart = parts.shift();
-    const { name, type } = this.parseNameType(nameTypePart);
-    let locatorStr = name;
-    if (type) {
-      locatorStr += `.${type}`;
-    }
-    locatorStr += `@${version}`;
-    try {
-      return parseRXL(locatorStr);
-    } catch {
-      return null;
-    }
-  }
-  parseCacheEntry(entry) {
-    const dirPath = entry.replace(/[/\\]manifest\.json$/, "");
-    const parts = dirPath.split(/[/\\]/);
-    if (parts.length < 3) {
-      return null;
-    }
-    const version = parts.pop();
-    const nameTypePart = parts.pop();
-    const domain = parts.shift();
-    const path = parts.length > 0 ? parts.join("/") : undefined;
-    const { name, type } = this.parseNameType(nameTypePart);
-    let locatorStr = domain;
-    if (path) {
-      locatorStr += `/${path}`;
-    }
-    locatorStr += `/${name}`;
-    if (type) {
-      locatorStr += `.${type}`;
-    }
-    locatorStr += `@${version}`;
-    try {
-      return parseRXL(locatorStr);
-    } catch {
-      return null;
-    }
-  }
-  parseNameType(nameTypePart) {
-    const dotIndex = nameTypePart.lastIndexOf(".");
-    if (dotIndex !== -1) {
-      return {
-        name: nameTypePart.substring(0, dotIndex),
-        type: nameTypePart.substring(dotIndex + 1)
-      };
-    } else {
-      return { name: nameTypePart, type: undefined };
-    }
-  }
-}
-
-class RemoteRegistry {
-  endpoint;
-  typeHandler;
-  constructor(config) {
-    this.endpoint = config.endpoint.replace(/\/$/, "");
-    this.typeHandler = TypeHandlerChain.create();
-  }
-  supportType(type) {
-    this.typeHandler.register(type);
-  }
-  async pull(_locator, _options) {
-    throw new RegistryError("Cannot pull to remote registry - use local registry for pulling");
-  }
-  async publish(_resource, _options) {
-    throw new RegistryError("Remote registry publish not implemented yet");
-  }
-  async link(_resource) {
-    throw new RegistryError("Cannot link to remote registry - use local registry for linking");
-  }
-  async get(locator) {
-    const manifestUrl = `${this.endpoint}/resource?locator=${encodeURIComponent(locator)}`;
-    const manifestResponse = await fetch(manifestUrl);
-    if (!manifestResponse.ok) {
-      if (manifestResponse.status === 404) {
-        throw new RegistryError(`Resource not found: ${locator}`);
-      }
-      throw new RegistryError(`Failed to fetch resource: ${manifestResponse.statusText}`);
-    }
-    const manifestData = await manifestResponse.json();
-    const manifest = createRXM(manifestData);
-    const contentUrl = `${this.endpoint}/content?locator=${encodeURIComponent(locator)}`;
-    const contentResponse = await fetch(contentUrl);
-    if (!contentResponse.ok) {
-      throw new RegistryError(`Failed to fetch content: ${contentResponse.statusText}`);
-    }
-    const contentBuffer = Buffer.from(await contentResponse.arrayBuffer());
-    return this.typeHandler.deserialize(contentBuffer, manifest);
-  }
-  async resolve(locator) {
-    const rxr = await this.get(locator);
-    return this.typeHandler.resolve(rxr);
-  }
-  async exists(locator) {
-    const url = `${this.endpoint}/exists?locator=${encodeURIComponent(locator)}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      return false;
-    }
-    const data = await response.json();
-    return data.exists === true;
-  }
-  async delete(_locator) {
-    throw new RegistryError("Cannot delete from remote registry - use local registry for deletion");
-  }
-  async search(options) {
-    const params = new URLSearchParams;
-    if (options?.query)
-      params.set("query", options.query);
-    if (options?.limit !== undefined)
-      params.set("limit", String(options.limit));
-    if (options?.offset !== undefined)
-      params.set("offset", String(options.offset));
-    const url = `${this.endpoint}/search?${params.toString()}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new RegistryError(`Search failed: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return (data.results || []).map((locator) => parseRXL(locator));
-  }
-}
-async function discoverRegistry(domain) {
-  const wellKnownUrl = `https://${domain}/.well-known/resourcex`;
-  try {
-    const response = await fetch(wellKnownUrl);
-    if (!response.ok) {
-      throw new RegistryError(`Well-known discovery failed for ${domain}: ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (!data.registries || !Array.isArray(data.registries) || data.registries.length === 0) {
-      throw new RegistryError(`Invalid well-known response for ${domain}: missing or empty registries`);
-    }
-    return {
-      domain,
-      registries: data.registries
-    };
-  } catch (error) {
-    if (error instanceof RegistryError) {
-      throw error;
-    }
-    throw new RegistryError(`Failed to discover registry for ${domain}: ${error.message}`);
-  }
-}
-var DEFAULT_GIT_CACHE = `${homedir2()}/.resourcex/.git-cache`;
-
-class GitRegistry {
-  url;
-  ref;
-  basePath;
-  cacheDir;
-  typeHandler;
-  trustedDomain;
-  constructor(config) {
-    this.url = config.url;
-    this.ref = config.ref ?? "main";
-    this.basePath = config.basePath ?? ".resourcex";
-    this.typeHandler = TypeHandlerChain.create();
-    this.trustedDomain = config.domain;
-    if (this.isRemoteUrl(config.url) && !config.domain) {
-      throw new RegistryError(`Remote git registry requires a trusted domain.
-
-` + `Either:
-` + `1. Use discoverRegistry("your-domain.com") to auto-bind domain
-` + `2. Explicitly set domain: createRegistry({ type: "git", url: "...", domain: "your-domain.com" })
-
-` + `This ensures resources from untrusted sources cannot impersonate your domain.`);
-    }
-    this.cacheDir = this.buildCacheDir(config.url);
-  }
-  isRemoteUrl(url) {
-    return url.startsWith("git@") || url.startsWith("https://") || url.startsWith("http://");
-  }
-  buildCacheDir(url) {
-    let normalized = url;
-    if (url.startsWith("git@")) {
-      normalized = url.slice(4).replace(":", "/");
-    }
-    if (normalized.endsWith(".git")) {
-      normalized = normalized.slice(0, -4);
-    }
-    const dirName = normalized.replace(/\//g, "-");
-    return join22(DEFAULT_GIT_CACHE, dirName);
-  }
-  supportType(type) {
-    this.typeHandler.register(type);
-  }
-  async ensureCloned() {
-    const gitDir = join22(this.cacheDir, ".git");
-    try {
-      await stat22(gitDir);
-      this.gitExec(`fetch origin ${this.ref}`);
-      this.gitExec(`checkout FETCH_HEAD`);
-    } catch {
-      await mkdir22(DEFAULT_GIT_CACHE, { recursive: true });
-      execSync(`git clone --depth 1 --branch ${this.ref} ${this.url} ${this.cacheDir}`, {
-        stdio: "pipe"
-      });
-    }
-  }
-  gitExec(command) {
-    execSync(`git -C ${this.cacheDir} ${command}`, { stdio: "pipe" });
-  }
-  buildResourcePath(locator) {
-    const rxl = parseRXL(locator);
-    const domain = rxl.domain ?? "localhost";
-    const version = rxl.version ?? "latest";
-    let path = join22(this.cacheDir, this.basePath, domain);
-    if (rxl.path) {
-      path = join22(path, rxl.path);
-    }
-    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    return join22(path, resourceName, version);
-  }
-  async get(locator) {
-    await this.ensureCloned();
-    const resourcePath = this.buildResourcePath(locator);
-    const manifestPath = join22(resourcePath, "manifest.json");
-    try {
-      await stat22(manifestPath);
-    } catch {
-      throw new RegistryError(`Resource not found: ${locator}`);
-    }
-    const manifestContent = await readFile22(manifestPath, "utf-8");
-    const manifestData = JSON.parse(manifestContent);
-    const manifest = createRXM(manifestData);
-    if (this.trustedDomain && manifest.domain !== this.trustedDomain) {
-      throw new RegistryError(`Untrusted domain: resource claims "${manifest.domain}" but registry only trusts "${this.trustedDomain}"`);
-    }
-    const contentPath = join22(resourcePath, "content.tar.gz");
-    const data = await readFile22(contentPath);
-    return this.typeHandler.deserialize(data, manifest);
-  }
-  async resolve(locator) {
-    const rxr = await this.get(locator);
-    return this.typeHandler.resolve(rxr);
-  }
-  async exists(locator) {
-    try {
-      await this.ensureCloned();
-      const resourcePath = this.buildResourcePath(locator);
-      const manifestPath = join22(resourcePath, "manifest.json");
-      await stat22(manifestPath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async search(options) {
-    await this.ensureCloned();
-    const { query, limit, offset = 0 } = options ?? {};
-    const locators = [];
-    const baseDir = join22(this.cacheDir, this.basePath);
-    try {
-      const entries = await this.listRecursive(baseDir);
-      for (const entry of entries) {
-        if (!entry.endsWith("manifest.json"))
-          continue;
-        const relativePath = entry.slice(baseDir.length + 1);
-        const rxl = this.parseEntryToRXL(relativePath);
-        if (rxl)
-          locators.push(rxl);
-      }
-    } catch {
-      return [];
-    }
-    let filtered = locators;
-    if (query) {
-      const lowerQuery = query.toLowerCase();
-      filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
-        return searchText.includes(lowerQuery);
-      });
-    }
-    let result = filtered.slice(offset);
-    if (limit !== undefined) {
-      result = result.slice(0, limit);
-    }
-    return result;
-  }
-  async listRecursive(dir) {
-    const results = [];
-    try {
-      const entries = await readdir22(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = join22(dir, entry.name);
-        if (entry.isDirectory()) {
-          const subEntries = await this.listRecursive(fullPath);
-          results.push(...subEntries);
-        } else {
-          results.push(fullPath);
-        }
-      }
-    } catch {}
-    return results;
-  }
-  parseEntryToRXL(entry) {
-    const dirPath = entry.replace(/[/\\]manifest\.json$/, "");
-    const parts = dirPath.split(/[/\\]/);
-    if (parts.length < 3)
-      return null;
-    const version = parts.pop();
-    const nameTypePart = parts.pop();
-    const domain = parts.shift();
-    const path = parts.length > 0 ? parts.join("/") : undefined;
-    const dotIndex = nameTypePart.lastIndexOf(".");
-    let name;
-    let type;
-    if (dotIndex !== -1) {
-      name = nameTypePart.substring(0, dotIndex);
-      type = nameTypePart.substring(dotIndex + 1);
-    } else {
-      name = nameTypePart;
-      type = undefined;
-    }
-    let locatorStr = domain;
-    if (path)
-      locatorStr += `/${path}`;
-    locatorStr += `/${name}`;
-    if (type)
-      locatorStr += `.${type}`;
-    locatorStr += `@${version}`;
-    try {
-      return parseRXL(locatorStr);
-    } catch {
-      return null;
-    }
-  }
-  async pull(_locator, _options) {
-    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.pull()");
-  }
-  async publish(_resource, _options) {
-    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.publish()");
-  }
-  async link(_resource) {
-    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.link()");
-  }
-  async delete(_locator) {
-    throw new RegistryError("GitRegistry is read-only - use LocalRegistry.delete()");
-  }
-}
-function createRegistry(config) {
-  if (isRemoteConfig(config)) {
-    return new RemoteRegistry(config);
-  }
-  if (isGitConfig(config)) {
-    return new GitRegistry(config);
-  }
-  return new LocalRegistry(config);
-}
-
-// src/transport/rxr.ts
-var registryCache = new Map;
-
-class RxrTransport {
-  registry;
-  name = "rxr";
-  constructor(registry) {
-    this.registry = registry;
-  }
-  async get(location, _params) {
-    const { domain, rxl, internalPath } = this.parseLocation(location);
-    const registry = await this.getRegistry(domain);
-    const rxr = await registry.get(rxl);
-    const files = await rxr.content.files();
-    const file = files.get(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 { domain, rxl, internalPath } = this.parseLocation(location);
-      const registry = await this.getRegistry(domain);
-      const rxr = await registry.get(rxl);
-      const files = await rxr.content.files();
-      return files.has(internalPath);
-    } catch {
-      return false;
-    }
-  }
-  async delete(_location) {
-    throw new TransportError("RXR transport is read-only", this.name);
-  }
-  async getRegistry(domain) {
-    if (this.registry) {
-      return this.registry;
-    }
-    if (registryCache.has(domain)) {
-      return registryCache.get(domain);
-    }
-    let registry;
-    if (domain === "localhost") {
-      registry = createRegistry();
-    } else {
-      try {
-        const discovery = await discoverRegistry(domain);
-        const registryUrl = discovery.registries[0];
-        if (this.isGitUrl(registryUrl)) {
-          registry = createRegistry({
-            type: "git",
-            url: registryUrl,
-            domain: discovery.domain
-          });
-        } else {
-          registry = createRegistry({ endpoint: registryUrl });
-        }
-      } catch (error) {
-        throw new TransportError(`Failed to discover registry for domain ${domain}: ${error.message}`, this.name);
-      }
-    }
-    registryCache.set(domain, registry);
-    return registry;
-  }
-  isGitUrl(url) {
-    return url.startsWith("git@") || url.endsWith(".git");
-  }
-  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);
-    }
-    const firstSlash = location.indexOf("/");
-    const domain = firstSlash > 0 ? location.slice(0, firstSlash) : "localhost";
-    return {
-      domain,
-      rxl: location.slice(0, slashAfterVersion),
-      internalPath: location.slice(slashAfterVersion + 1)
-    };
-  }
-}
-function clearRegistryCache() {
-  registryCache.clear();
-}
 // src/semantic/text.ts
 class TextSemanticHandler {
   name = "text";
@@ -2564,20 +518,18 @@ function createARP(config) {
 }
 
 // src/index.ts
-var VERSION = "2.0.0";
+var VERSION = "2.1.0";
 export {
   textSemantic,
   httpsTransport,
   httpTransport,
   fileTransport,
   createARP,
-  clearRegistryCache,
   binarySemantic,
   VERSION,
   TransportError,
   TextSemanticHandler,
   SemanticError,
-  RxrTransport,
   ParseError,
   HttpTransportHandler,
   FileTransportHandler,
@@ -2586,4 +538,4 @@ export {
   ARP
 };
 
-//# debugId=1847C08CED2B25BC64756E2164756E21
+//# debugId=C0084E960EA7C5F164756E2164756E21