@resourcexjs/registry 2.2.0 → 2.3.0

package/dist/index.js

@@ -23447,13 +23447,6 @@ var require_ours = __commonJS((exports, module) => {
   module.exports.default = module.exports;
 });
 
-// src/types.ts
-function isRemoteConfig(config) {
-  return config !== undefined && "endpoint" in config;
-}
-function isGitConfig(config) {
-  return config !== undefined && "type" in config && config.type === "git";
-}
 // ../core/dist/index.js
 import { gzip, gunzip } from "node:zlib";
 import { promisify } from "node:util";
@@ -24679,9 +24672,81 @@ async function unpackTar(archive, options = {}) {
 var gzipAsync2 = promisify2(gzip2);
 var gunzipAsync2 = promisify2(gunzip2);
 
-class RXCImpl {
+class RXPImpl {
+  _files;
+  _pathsCache = null;
+  _treeCache = null;
+  constructor(files) {
+    this._files = files;
+  }
+  paths() {
+    if (this._pathsCache) {
+      return this._pathsCache;
+    }
+    this._pathsCache = Array.from(this._files.keys()).sort();
+    return this._pathsCache;
+  }
+  tree() {
+    if (this._treeCache) {
+      return this._treeCache;
+    }
+    const root = new Map;
+    for (const path of this._files.keys()) {
+      const parts = path.split("/");
+      let currentLevel = root;
+      for (let i = 0;i < parts.length; i++) {
+        const part = parts[i];
+        const isFile = i === parts.length - 1;
+        if (!currentLevel.has(part)) {
+          const treeNode2 = {
+            node: {
+              name: part,
+              type: isFile ? "file" : "directory",
+              children: isFile ? undefined : []
+            },
+            children: new Map
+          };
+          currentLevel.set(part, treeNode2);
+        }
+        const treeNode = currentLevel.get(part);
+        if (!isFile) {
+          currentLevel = treeNode.children;
+        }
+      }
+    }
+    const convertToPathNodes = (level) => {
+      return Array.from(level.values()).map((treeNode) => {
+        if (treeNode.node.type === "directory" && treeNode.children.size > 0) {
+          treeNode.node.children = convertToPathNodes(treeNode.children);
+        }
+        return treeNode.node;
+      });
+    };
+    this._treeCache = convertToPathNodes(root);
+    return this._treeCache;
+  }
+  async file(path) {
+    const content = this._files.get(path);
+    if (!content) {
+      throw new ContentError(`file not found: ${path}`);
+    }
+    return content;
+  }
+  async files() {
+    return new Map(this._files);
+  }
+  async pack() {
+    const filesRecord = {};
+    for (const [path, content] of this._files) {
+      filesRecord[path] = content;
+    }
+    return createRXA(filesRecord);
+  }
+}
+
+class RXAImpl {
   _buffer;
-  _filesCache = null;
+  _rxpCache = null;
   constructor(buffer) {
     this._buffer = buffer;
   }
@@ -24697,17 +24762,9 @@ class RXCImpl {
   async buffer() {
     return this._buffer;
   }
-  async file(path) {
-    const filesMap = await this.files();
-    const content = filesMap.get(path);
-    if (!content) {
-      throw new ContentError(`file not found: ${path}`);
-    }
-    return content;
-  }
-  async files() {
-    if (this._filesCache) {
-      return this._filesCache;
+  async extract() {
+    if (this._rxpCache) {
+      return this._rxpCache;
     }
     const tarBuffer = await gunzipAsync2(this._buffer);
     const entries = await unpackTar(tarBuffer);
@@ -24717,16 +24774,16 @@ class RXCImpl {
         filesMap.set(entry.header.name, Buffer.from(entry.data));
       }
     }
-    this._filesCache = filesMap;
-    return filesMap;
+    this._rxpCache = new RXPImpl(filesMap);
+    return this._rxpCache;
   }
 }
-function isArchiveInput(input) {
-  return "archive" in input && Buffer.isBuffer(input.archive);
+function isBufferInput(input) {
+  return "buffer" in input && Buffer.isBuffer(input.buffer);
 }
-async function createRXC(input) {
-  if (isArchiveInput(input)) {
-    return new RXCImpl(input.archive);
+async function createRXA(input) {
+  if (isBufferInput(input)) {
+    return new RXAImpl(input.buffer);
   }
   const entries = Object.entries(input).map(([name, content]) => {
     const body = typeof content === "string" ? content : content instanceof Uint8Array ? content : new Uint8Array(content);
@@ -24738,7 +24795,7 @@ async function createRXC(input) {
   });
   const tarBuffer = await packTar(entries);
   const gzipBuffer = await gzipAsync2(Buffer.from(tarBuffer));
-  return new RXCImpl(gzipBuffer);
+  return new RXAImpl(gzipBuffer);
 }
 
 class ResourceTypeError extends ResourceXError2 {
@@ -24749,13 +24806,13 @@ class ResourceTypeError extends ResourceXError2 {
 }
 var textSerializer = {
   async serialize(rxr) {
-    return rxr.content.buffer();
+    return rxr.archive.buffer();
   },
   async deserialize(data, manifest) {
     return {
       locator: parseRXL2(manifest.toLocator()),
       manifest,
-      content: await createRXC({ archive: data })
+      archive: await createRXA({ buffer: data })
     };
   }
 };
@@ -24766,7 +24823,8 @@ var textResolver = {
       resource: rxr,
       schema: undefined,
       execute: async () => {
-        const buffer = await rxr.content.file("content");
+        const pkg = await rxr.archive.extract();
+        const buffer = await pkg.file("content");
         return buffer.toString("utf-8");
       }
     };
@@ -24781,13 +24839,13 @@ var textType = {
 };
 var jsonSerializer = {
   async serialize(rxr) {
-    return rxr.content.buffer();
+    return rxr.archive.buffer();
   },
   async deserialize(data, manifest) {
     return {
       locator: parseRXL2(manifest.toLocator()),
       manifest,
-      content: await createRXC({ archive: data })
+      archive: await createRXA({ buffer: data })
     };
   }
 };
@@ -24798,7 +24856,8 @@ var jsonResolver = {
       resource: rxr,
       schema: undefined,
       execute: async () => {
-        const buffer = await rxr.content.file("content");
+        const pkg = await rxr.archive.extract();
+        const buffer = await pkg.file("content");
         return JSON.parse(buffer.toString("utf-8"));
       }
     };
@@ -24813,13 +24872,13 @@ var jsonType = {
 };
 var binarySerializer = {
   async serialize(rxr) {
-    return rxr.content.buffer();
+    return rxr.archive.buffer();
   },
   async deserialize(data, manifest) {
     return {
       locator: parseRXL2(manifest.toLocator()),
       manifest,
-      content: await createRXC({ archive: data })
+      archive: await createRXA({ buffer: data })
     };
   }
 };
@@ -24830,7 +24889,8 @@ var binaryResolver = {
       resource: rxr,
       schema: undefined,
       execute: async () => {
-        return rxr.content.file("content");
+        const pkg = await rxr.archive.extract();
+        return pkg.file("content");
       }
     };
   }
@@ -26563,9 +26623,81 @@ async function unpackTar2(archive, options = {}) {
 var gzipAsync3 = promisify3(gzip3);
 var gunzipAsync3 = promisify3(gunzip3);
 
-class RXCImpl2 {
+class RXPImpl2 {
+  _files;
+  _pathsCache = null;
+  _treeCache = null;
+  constructor(files) {
+    this._files = files;
+  }
+  paths() {
+    if (this._pathsCache) {
+      return this._pathsCache;
+    }
+    this._pathsCache = Array.from(this._files.keys()).sort();
+    return this._pathsCache;
+  }
+  tree() {
+    if (this._treeCache) {
+      return this._treeCache;
+    }
+    const root = new Map;
+    for (const path of this._files.keys()) {
+      const parts = path.split("/");
+      let currentLevel = root;
+      for (let i = 0;i < parts.length; i++) {
+        const part = parts[i];
+        const isFile = i === parts.length - 1;
+        if (!currentLevel.has(part)) {
+          const treeNode2 = {
+            node: {
+              name: part,
+              type: isFile ? "file" : "directory",
+              children: isFile ? undefined : []
+            },
+            children: new Map
+          };
+          currentLevel.set(part, treeNode2);
+        }
+        const treeNode = currentLevel.get(part);
+        if (!isFile) {
+          currentLevel = treeNode.children;
+        }
+      }
+    }
+    const convertToPathNodes = (level) => {
+      return Array.from(level.values()).map((treeNode) => {
+        if (treeNode.node.type === "directory" && treeNode.children.size > 0) {
+          treeNode.node.children = convertToPathNodes(treeNode.children);
+        }
+        return treeNode.node;
+      });
+    };
+    this._treeCache = convertToPathNodes(root);
+    return this._treeCache;
+  }
+  async file(path) {
+    const content = this._files.get(path);
+    if (!content) {
+      throw new ContentError2(`file not found: ${path}`);
+    }
+    return content;
+  }
+  async files() {
+    return new Map(this._files);
+  }
+  async pack() {
+    const filesRecord = {};
+    for (const [path, content] of this._files) {
+      filesRecord[path] = content;
+    }
+    return createRXA2(filesRecord);
+  }
+}
+
+class RXAImpl2 {
   _buffer;
-  _filesCache = null;
+  _rxpCache = null;
   constructor(buffer) {
     this._buffer = buffer;
   }
@@ -26581,17 +26713,9 @@ class RXCImpl2 {
   async buffer() {
     return this._buffer;
   }
-  async file(path) {
-    const filesMap = await this.files();
-    const content = filesMap.get(path);
-    if (!content) {
-      throw new ContentError2(`file not found: ${path}`);
-    }
-    return content;
-  }
-  async files() {
-    if (this._filesCache) {
-      return this._filesCache;
+  async extract() {
+    if (this._rxpCache) {
+      return this._rxpCache;
     }
     const tarBuffer = await gunzipAsync3(this._buffer);
     const entries = await unpackTar2(tarBuffer);
@@ -26601,16 +26725,16 @@ class RXCImpl2 {
         filesMap.set(entry.header.name, Buffer.from(entry.data));
       }
     }
-    this._filesCache = filesMap;
-    return filesMap;
+    this._rxpCache = new RXPImpl2(filesMap);
+    return this._rxpCache;
   }
 }
-function isArchiveInput2(input) {
-  return "archive" in input && Buffer.isBuffer(input.archive);
+function isBufferInput2(input) {
+  return "buffer" in input && Buffer.isBuffer(input.buffer);
 }
-async function createRXC2(input) {
-  if (isArchiveInput2(input)) {
-    return new RXCImpl2(input.archive);
+async function createRXA2(input) {
+  if (isBufferInput2(input)) {
+    return new RXAImpl2(input.buffer);
   }
   const entries = Object.entries(input).map(([name, content]) => {
     const body = typeof content === "string" ? content : content instanceof Uint8Array ? content : new Uint8Array(content);
@@ -26622,7 +26746,7 @@ async function createRXC2(input) {
   });
   const tarBuffer = await packTar2(entries);
   const gzipBuffer = await gzipAsync3(Buffer.from(tarBuffer));
-  return new RXCImpl2(gzipBuffer);
+  return new RXAImpl2(gzipBuffer);
 }
 
 class FolderLoader {
@@ -26673,12 +26797,12 @@ class FolderLoader {
     if (Object.keys(files).length === 0) {
       throw new ResourceXError3("No content files found in resource folder");
     }
-    const content = await createRXC2(files);
+    const archive = await createRXA2(files);
     const locator = parseRXL3(manifest.toLocator());
     return {
       locator,
       manifest,
-      content
+      archive
     };
   }
   async readFolderFiles(folderPath, basePath = folderPath) {
@@ -26786,7 +26910,7 @@ class LocalRegistry {
     const manifestContent = manifestResource.content.toString("utf-8");
     const manifestData = JSON.parse(manifestContent);
     const manifest = createRXM(manifestData);
-    const contentPath = join3(resourcePath, "content.tar.gz");
+    const contentPath = join3(resourcePath, "archive.tar.gz");
     const contentArl = this.arp.parse(this.toArpUrl(contentPath));
     const contentResource = await contentArl.resolve();
     const data = contentResource.content;
@@ -26822,7 +26946,7 @@ class LocalRegistry {
     const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
     const manifestContent = Buffer.from(JSON.stringify(resource.manifest.toJSON(), null, 2), "utf-8");
     await manifestArl.deposit(manifestContent);
-    const contentPath = join3(resourcePath, "content.tar.gz");
+    const contentPath = join3(resourcePath, "archive.tar.gz");
     const contentArl = this.arp.parse(this.toArpUrl(contentPath));
     const serialized = await this.typeHandler.serialize(resource);
     await contentArl.deposit(serialized);
@@ -26966,6 +27090,12 @@ class LocalRegistry {
 }
 // src/RemoteRegistry.ts
 class RemoteRegistry {
+  static canHandle(url) {
+    return url.startsWith("https://") || url.startsWith("http://");
+  }
+  static create(config) {
+    return new RemoteRegistry({ endpoint: config.url });
+  }
   endpoint;
   typeHandler;
   constructor(config) {
@@ -27061,6 +27191,20 @@ async function discoverRegistry(domain) {
     throw new RegistryError(`Failed to discover registry for ${domain}: ${error.message}`);
   }
 }
+// src/types.ts
+function isUrlConfig(config) {
+  return config !== undefined && "url" in config && !("type" in config) && !("endpoint" in config);
+}
+function isRemoteConfig(config) {
+  return config !== undefined && "endpoint" in config;
+}
+function isGitConfig(config) {
+  return config !== undefined && "type" in config && config.type === "git";
+}
+function isGitHubConfig(config) {
+  return config !== undefined && "type" in config && config.type === "github";
+}
+
 // src/GitRegistry.ts
 var import_isomorphic_git = __toESM(require_isomorphic_git(), 1);
 import { homedir as homedir2 } from "node:os";
@@ -27224,6 +27368,71 @@ async function request({
 var index = { request };
 var node_default = index;
 
+// src/middleware/RegistryMiddleware.ts
+class RegistryMiddleware {
+  inner;
+  constructor(inner) {
+    this.inner = inner;
+  }
+  supportType(type) {
+    this.inner.supportType(type);
+  }
+  link(path) {
+    return this.inner.link(path);
+  }
+  add(source) {
+    return this.inner.add(source);
+  }
+  pull(locator, options) {
+    return this.inner.pull(locator, options);
+  }
+  publish(source, options) {
+    return this.inner.publish(source, options);
+  }
+  get(locator) {
+    return this.inner.get(locator);
+  }
+  resolve(locator) {
+    return this.inner.resolve(locator);
+  }
+  exists(locator) {
+    return this.inner.exists(locator);
+  }
+  delete(locator) {
+    return this.inner.delete(locator);
+  }
+  search(options) {
+    return this.inner.search(options);
+  }
+}
+
+// src/middleware/DomainValidation.ts
+class DomainValidation extends RegistryMiddleware {
+  trustedDomain;
+  constructor(inner, trustedDomain) {
+    super(inner);
+    this.trustedDomain = trustedDomain;
+  }
+  validateDomain(rxr) {
+    if (rxr.manifest.domain !== this.trustedDomain) {
+      throw new RegistryError(`Untrusted domain: resource claims "${rxr.manifest.domain}" but registry only trusts "${this.trustedDomain}"`);
+    }
+  }
+  async get(locator) {
+    const rxr = await this.inner.get(locator);
+    this.validateDomain(rxr);
+    return rxr;
+  }
+  async resolve(locator) {
+    const rxr = await this.inner.get(locator);
+    this.validateDomain(rxr);
+    return this.inner.resolve(locator);
+  }
+}
+function withDomainValidation(registry, trustedDomain) {
+  return new DomainValidation(registry, trustedDomain);
+}
+
 // src/GitRegistry.ts
 var DEFAULT_GIT_CACHE = `${homedir2()}/.resourcex/.git-cache`;
 var MAX_RETRIES = 2;
@@ -27232,6 +27441,19 @@ function isLocalPath(url) {
 }
 
 class GitRegistry {
+  static canHandle(url) {
+    return url.startsWith("git@") || url.endsWith(".git");
+  }
+  static create(config) {
+    const registry = new GitRegistry({
+      type: "git",
+      url: config.url,
+      ref: config.ref,
+      basePath: config.basePath,
+      domain: config.domain
+    });
+    return config.domain ? withDomainValidation(registry, config.domain) : registry;
+  }
   url;
   ref;
   basePath;
@@ -27364,7 +27586,7 @@ class GitRegistry {
     const manifestContent = manifestResource.content.toString("utf-8");
     const manifestData = JSON.parse(manifestContent);
     const manifest = createRXM(manifestData);
-    const contentPath = join4(resourcePath, "content.tar.gz");
+    const contentPath = join4(resourcePath, "archive.tar.gz");
     const contentArl = this.arp.parse(this.toArpUrl(contentPath));
     const contentResource = await contentArl.resolve();
     const data = contentResource.content;
@@ -27465,109 +27687,333 @@ class GitRegistry {
     throw new RegistryError("GitRegistry is read-only - use LocalRegistry.delete()");
   }
 }
-// src/middleware/RegistryMiddleware.ts
-class RegistryMiddleware {
-  inner;
-  constructor(inner) {
-    this.inner = inner;
+
+// src/GitHubRegistry.ts
+import { homedir as homedir3 } from "node:os";
+import { join as join5 } from "node:path";
+import { gunzipSync } from "node:zlib";
+var DEFAULT_GITHUB_CACHE = `${homedir3()}/.resourcex/.github-cache`;
+function parseGitHubUrl(url) {
+  if (!url.startsWith("https://github.com/")) {
+    throw new RegistryError(`Invalid GitHub URL: ${url}. Expected format: https://github.com/owner/repo`);
+  }
+  const path = url.slice("https://github.com/".length);
+  const parts = path.split("/");
+  if (parts.length < 2) {
+    throw new RegistryError(`Invalid GitHub URL: ${url}. Expected format: https://github.com/owner/repo`);
+  }
+  const owner = parts[0];
+  const repo = parts[1];
+  let branch = "main";
+  if (parts.length >= 4 && parts[2] === "tree") {
+    branch = parts[3];
+  }
+  return { owner, repo, branch };
+}
+function isGitHubUrl(url) {
+  return url.startsWith("https://github.com/");
+}
+
+class GitHubRegistry {
+  static canHandle(url) {
+    return isGitHubUrl(url);
+  }
+  static create(config) {
+    const registry = new GitHubRegistry({
+      url: config.url,
+      ref: config.ref,
+      basePath: config.basePath
+    });
+    return config.domain ? withDomainValidation(registry, config.domain) : registry;
   }
-  supportType(type) {
-    this.inner.supportType(type);
+  url;
+  owner;
+  repo;
+  ref;
+  basePath;
+  cacheDir;
+  typeHandler;
+  arp;
+  tarballDownloaded = false;
+  constructor(config) {
+    this.url = config.url;
+    const parsed = parseGitHubUrl(config.url);
+    this.owner = parsed.owner;
+    this.repo = parsed.repo;
+    this.ref = config.ref ?? parsed.branch;
+    this.basePath = config.basePath ?? ".resourcex";
+    this.typeHandler = TypeHandlerChain.create();
+    this.arp = createARP();
+    this.cacheDir = this.buildCacheDir();
   }
-  link(path) {
-    return this.inner.link(path);
+  buildCacheDir() {
+    const dirName = `github.com-${this.owner}-${this.repo}`;
+    return join5(DEFAULT_GITHUB_CACHE, dirName);
   }
-  add(source) {
-    return this.inner.add(source);
+  supportType(type) {
+    this.typeHandler.register(type);
   }
-  pull(locator, options) {
-    return this.inner.pull(locator, options);
+  toArpUrl(filePath) {
+    return `arp:binary:file://${filePath}`;
   }
-  publish(source, options) {
-    return this.inner.publish(source, options);
+  getTarballUrl() {
+    return `https://github.com/${this.owner}/${this.repo}/archive/refs/heads/${this.ref}.tar.gz`;
   }
-  get(locator) {
-    return this.inner.get(locator);
+  async ensureDownloaded() {
+    if (this.tarballDownloaded) {
+      return;
+    }
+    const tarballUrl = this.getTarballUrl();
+    const response = await fetch(tarballUrl, {
+      headers: {
+        "User-Agent": "ResourceX/1.0"
+      }
+    });
+    if (!response.ok) {
+      throw new RegistryError(`Failed to download tarball from ${tarballUrl}: ${response.status} ${response.statusText}`);
+    }
+    const tarballBuffer = Buffer.from(await response.arrayBuffer());
+    await this.extractTarball(tarballBuffer);
+    this.tarballDownloaded = true;
+  }
+  async extractTarball(tarballBuffer) {
+    const tarBuffer = gunzipSync(tarballBuffer);
+    const files = this.parseTar(tarBuffer);
+    const cacheArl = this.arp.parse(this.toArpUrl(this.cacheDir));
+    await cacheArl.mkdir();
+    for (const [path, content] of files) {
+      const parts = path.split("/");
+      if (parts.length < 2)
+        continue;
+      const relativePath = parts.slice(1).join("/");
+      if (!relativePath)
+        continue;
+      const fullPath = join5(this.cacheDir, relativePath);
+      const parentDir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+      if (parentDir) {
+        const parentArl = this.arp.parse(this.toArpUrl(parentDir));
+        await parentArl.mkdir();
+      }
+      const fileArl = this.arp.parse(this.toArpUrl(fullPath));
+      await fileArl.deposit(content);
+    }
   }
-  resolve(locator) {
-    return this.inner.resolve(locator);
+  parseTar(tarBuffer) {
+    const files = new Map;
+    let offset = 0;
+    while (offset < tarBuffer.length) {
+      const header = tarBuffer.subarray(offset, offset + 512);
+      if (header[0] === 0) {
+        break;
+      }
+      let filename = "";
+      for (let i = 0;i < 100 && header[i] !== 0; i++) {
+        filename += String.fromCharCode(header[i]);
+      }
+      let prefix = "";
+      for (let i = 345;i < 500 && header[i] !== 0; i++) {
+        prefix += String.fromCharCode(header[i]);
+      }
+      if (prefix) {
+        filename = prefix + "/" + filename;
+      }
+      let sizeStr = "";
+      for (let i = 124;i < 136 && header[i] !== 0 && header[i] !== 32; i++) {
+        sizeStr += String.fromCharCode(header[i]);
+      }
+      const size = parseInt(sizeStr, 8) || 0;
+      const typeFlag = header[156];
+      offset += 512;
+      if (typeFlag === 48 || typeFlag === 0) {
+        if (size > 0) {
+          const content = tarBuffer.subarray(offset, offset + size);
+          files.set(filename, Buffer.from(content));
+        }
+      }
+      offset += Math.ceil(size / 512) * 512;
+    }
+    return files;
   }
-  exists(locator) {
-    return this.inner.exists(locator);
+  buildResourcePath(locator) {
+    const rxl = parseRXL(locator);
+    const domain = rxl.domain ?? "localhost";
+    const version = rxl.version ?? "latest";
+    let path = join5(this.cacheDir, this.basePath, domain);
+    if (rxl.path) {
+      path = join5(path, rxl.path);
+    }
+    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
+    return join5(path, resourceName, version);
   }
-  delete(locator) {
-    return this.inner.delete(locator);
+  async get(locator) {
+    await this.ensureDownloaded();
+    const resourcePath = this.buildResourcePath(locator);
+    const manifestPath = join5(resourcePath, "manifest.json");
+    const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
+    if (!await manifestArl.exists()) {
+      throw new RegistryError(`Resource not found: ${locator}`);
+    }
+    const manifestResource = await manifestArl.resolve();
+    const manifestContent = manifestResource.content.toString("utf-8");
+    const manifestData = JSON.parse(manifestContent);
+    const manifest = createRXM(manifestData);
+    const contentPath = join5(resourcePath, "archive.tar.gz");
+    const contentArl = this.arp.parse(this.toArpUrl(contentPath));
+    const contentResource = await contentArl.resolve();
+    const data = contentResource.content;
+    return this.typeHandler.deserialize(data, manifest);
   }
-  search(options) {
-    return this.inner.search(options);
+  async resolve(locator) {
+    const rxr = await this.get(locator);
+    return this.typeHandler.resolve(rxr);
   }
-}
-
-// src/middleware/DomainValidation.ts
-class DomainValidation extends RegistryMiddleware {
-  trustedDomain;
-  constructor(inner, trustedDomain) {
-    super(inner);
-    this.trustedDomain = trustedDomain;
+  async exists(locator) {
+    try {
+      await this.ensureDownloaded();
+      const resourcePath = this.buildResourcePath(locator);
+      const manifestPath = join5(resourcePath, "manifest.json");
+      const manifestArl = this.arp.parse(this.toArpUrl(manifestPath));
+      return await manifestArl.exists();
+    } catch {
+      return false;
+    }
   }
-  validateDomain(rxr) {
-    if (rxr.manifest.domain !== this.trustedDomain) {
-      throw new RegistryError(`Untrusted domain: resource claims "${rxr.manifest.domain}" but registry only trusts "${this.trustedDomain}"`);
+  async search(options) {
+    await this.ensureDownloaded();
+    const { query, limit, offset = 0 } = options ?? {};
+    const locators = [];
+    const baseDir = join5(this.cacheDir, this.basePath);
+    try {
+      const baseArl = this.arp.parse(this.toArpUrl(baseDir));
+      const entries = await baseArl.list({ recursive: true, pattern: "*.json" });
+      for (const entry of entries) {
+        if (!entry.endsWith("manifest.json"))
+          continue;
+        const rxl = this.parseEntryToRXL(entry);
+        if (rxl)
+          locators.push(rxl);
+      }
+    } catch {
+      return [];
+    }
+    let filtered = locators;
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      filtered = locators.filter((rxl) => {
+        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
+        return searchText.includes(lowerQuery);
+      });
+    }
+    let result = filtered.slice(offset);
+    if (limit !== undefined) {
+      result = result.slice(0, limit);
     }
+    return result;
   }
-  async get(locator) {
-    const rxr = await this.inner.get(locator);
-    this.validateDomain(rxr);
-    return rxr;
+  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 resolve(locator) {
-    const rxr = await this.inner.get(locator);
-    this.validateDomain(rxr);
-    return this.inner.resolve(locator);
+  async link(_path) {
+    throw new RegistryError("GitHubRegistry is read-only - use LocalRegistry.link()");
+  }
+  async add(_source) {
+    throw new RegistryError("GitHubRegistry is read-only - use LocalRegistry.add()");
+  }
+  async pull(_locator, _options) {
+    throw new RegistryError("GitHubRegistry is read-only - use LocalRegistry.pull()");
+  }
+  async publish(_source, _options) {
+    throw new RegistryError("GitHubRegistry is read-only - use LocalRegistry.publish()");
+  }
+  async delete(_locator) {
+    throw new RegistryError("GitHubRegistry is read-only - use LocalRegistry.delete()");
   }
-}
-function withDomainValidation(registry, trustedDomain) {
-  return new DomainValidation(registry, trustedDomain);
 }
 
 // src/createRegistry.ts
-function isRemoteGitUrl(url) {
+var URL_HANDLERS = [
+  GitHubRegistry,
+  GitRegistry,
+  RemoteRegistry
+];
+function isRemoteUrl(url) {
   return url.startsWith("git@") || url.startsWith("https://") || url.startsWith("http://");
 }
 function createRegistry(config) {
   if (isRemoteConfig(config)) {
     return new RemoteRegistry(config);
   }
+  if (isGitHubConfig(config)) {
+    const registry = new GitHubRegistry(config);
+    return config.domain ? withDomainValidation(registry, config.domain) : registry;
+  }
   if (isGitConfig(config)) {
-    if (isRemoteGitUrl(config.url) && !config.domain) {
+    if (isRemoteUrl(config.url) && !config.domain) {
       throw new RegistryError(`Remote git registry requires a trusted domain.
 
-` + `Either:
-` + `1. Use discoverRegistry("your-domain.com") to auto-bind domain
-` + `2. Explicitly set domain: createRegistry({ type: "git", url: "...", domain: "your-domain.com" })
-
-` + `This ensures resources from untrusted sources cannot impersonate your domain.`);
-    }
-    const gitRegistry = new GitRegistry(config);
-    if (config.domain) {
-      return withDomainValidation(gitRegistry, config.domain);
+` + `Use discoverRegistry() or explicitly set domain:
+` + `createRegistry({ type: "git", url: "...", domain: "your-domain.com" })`);
     }
-    return gitRegistry;
+    const registry = new GitRegistry(config);
+    return config.domain ? withDomainValidation(registry, config.domain) : registry;
+  }
+  if (isUrlConfig(config)) {
+    return createFromUrl(config);
   }
   return new LocalRegistry(config);
 }
+function createFromUrl(config) {
+  const { url, domain } = config;
+  if (isRemoteUrl(url) && !domain) {
+    throw new RegistryError(`Remote registry URL requires a trusted domain.
+
+` + `Use discoverRegistry() or explicitly set domain:
+` + `createRegistry({ url: "...", domain: "your-domain.com" })`);
+  }
+  for (const Handler of URL_HANDLERS) {
+    if (Handler.canHandle(url)) {
+      return Handler.create(config);
+    }
+  }
+  throw new RegistryError(`No handler found for URL: ${url}`);
+}
 export {
   withDomainValidation,
-  isRemoteConfig,
-  isGitConfig,
   discoverRegistry,
   createRegistry,
-  RemoteRegistry,
   RegistryMiddleware,
   RegistryError,
   LocalRegistry,
-  GitRegistry,
   DomainValidation
 };
 
-//# debugId=FE38D995FCCB453564756E2164756E21
+//# debugId=4521F4F0C842396664756E2164756E21