resourcexjs 2.5.0 → 2.5.2

package/dist/index.js

@@ -43,15 +43,16 @@ function define(input) {
   if (!obj.type || typeof obj.type !== "string") {
     throw new DefinitionError("type is required");
   }
-  if (!obj.version || typeof obj.version !== "string") {
-    throw new DefinitionError("version is required");
+  const tagValue = obj.tag ?? obj.version;
+  if (tagValue !== undefined && typeof tagValue !== "string") {
+    throw new DefinitionError("tag must be a string");
   }
   const rxd = {
     ...obj,
     name: obj.name,
     type: obj.type,
-    version: obj.version,
-    domain: typeof obj.domain === "string" ? obj.domain : "localhost",
+    tag: typeof tagValue === "string" ? tagValue : undefined,
+    registry: typeof obj.registry === "string" ? obj.registry : undefined,
     path: typeof obj.path === "string" ? obj.path : undefined,
     description: typeof obj.description === "string" ? obj.description : undefined,
     author: typeof obj.author === "string" ? obj.author : undefined,
@@ -63,11 +64,11 @@ function define(input) {
 }
 function manifest(rxd) {
   return {
-    domain: rxd.domain,
+    registry: rxd.registry,
     path: rxd.path,
     name: rxd.name,
     type: rxd.type,
-    version: rxd.version
+    tag: rxd.tag ?? "latest"
   };
 }
 function writeString(view, offset, size, value) {
@@ -987,11 +988,10 @@ async function archive(files2) {
 }
 function locate(rxm) {
   return {
-    domain: rxm.domain,
+    registry: rxm.registry,
     path: rxm.path,
     name: rxm.name,
-    type: rxm.type,
-    version: rxm.version
+    tag: rxm.tag
   };
 }
 function resource(rxm, rxa) {
@@ -1015,56 +1015,85 @@ async function extract(rxa) {
   return files2;
 }
 function format(rxl) {
-  let result = rxl.domain + "/";
+  let result = "";
+  if (rxl.registry) {
+    result += rxl.registry + "/";
+  }
   if (rxl.path) {
     result += rxl.path + "/";
   }
   result += rxl.name;
-  result += "." + rxl.type;
-  result += "@" + rxl.version;
+  if (rxl.tag && rxl.tag !== "latest") {
+    result += ":" + rxl.tag;
+  }
   return result;
 }
+function looksLikeRegistry(str) {
+  if (str.includes(":") && !str.includes("/")) {
+    return true;
+  }
+  if (str.includes(".")) {
+    return true;
+  }
+  if (str === "localhost") {
+    return true;
+  }
+  return false;
+}
 function parse(locator) {
   if (!locator || typeof locator !== "string") {
-    throw new LocatorError("locator must be a non-empty string", locator);
+    throw new LocatorError("Locator must be a non-empty string", locator);
   }
-  const atIndex = locator.lastIndexOf("@");
-  if (atIndex === -1) {
-    throw new LocatorError("locator must contain version (@)", locator);
+  if (locator.includes("@")) {
+    throw new LocatorError("Invalid locator format. Use name:tag instead of name@version", locator);
   }
-  const version = locator.slice(atIndex + 1);
-  const beforeVersion = locator.slice(0, atIndex);
-  if (!version) {
-    throw new LocatorError("version is required", locator);
+  const lastSlashIndex = locator.lastIndexOf("/");
+  let beforeSlash = "";
+  let afterSlash = locator;
+  if (lastSlashIndex !== -1) {
+    beforeSlash = locator.substring(0, lastSlashIndex);
+    afterSlash = locator.substring(lastSlashIndex + 1);
   }
-  const dotIndex = beforeVersion.lastIndexOf(".");
-  if (dotIndex === -1) {
-    throw new LocatorError("locator must contain type (.)", locator);
+  const colonIndex = afterSlash.lastIndexOf(":");
+  let name;
+  let tag;
+  if (colonIndex === -1) {
+    name = afterSlash;
+    tag = "latest";
+  } else {
+    name = afterSlash.substring(0, colonIndex);
+    tag = afterSlash.substring(colonIndex + 1);
   }
-  const type = beforeVersion.slice(dotIndex + 1);
-  const beforeType = beforeVersion.slice(0, dotIndex);
-  if (!type) {
-    throw new LocatorError("type is required", locator);
+  if (!name) {
+    throw new LocatorError("Name is required", locator);
   }
-  const parts = beforeType.split("/");
-  if (parts.length < 2) {
-    throw new LocatorError("locator must contain domain", locator);
+  if (!tag) {
+    throw new LocatorError("Tag cannot be empty. Use name:tag format or omit tag for :latest", locator);
   }
-  const domain = parts[0];
-  const name = parts[parts.length - 1];
-  const path = parts.length > 2 ? parts.slice(1, -1).join("/") : undefined;
-  if (!domain) {
-    throw new LocatorError("domain is required", locator);
+  if (lastSlashIndex === -1) {
+    return {
+      registry: undefined,
+      path: undefined,
+      name,
+      tag
+    };
   }
-  if (!name) {
-    throw new LocatorError("name is required", locator);
+  const parts = beforeSlash.split("/");
+  if (looksLikeRegistry(parts[0])) {
+    const registry = parts[0];
+    const path = parts.length > 1 ? parts.slice(1).join("/") : undefined;
+    return {
+      registry,
+      path,
+      name,
+      tag
+    };
   }
   return {
-    domain,
-    path,
+    registry: undefined,
+    path: beforeSlash,
     name,
-    type,
-    version
+    tag
   };
 }
 
@@ -16971,11 +17000,10 @@ var EOF_BUFFER3 = new Uint8Array(BLOCK_SIZE3 * 2);
 var gzipAsync3 = promisify5(gzip3);
 function locate2(rxm) {
   return {
-    domain: rxm.domain,
+    registry: rxm.registry,
     path: rxm.path,
     name: rxm.name,
-    type: rxm.type,
-    version: rxm.version
+    tag: rxm.tag
   };
 }
 function resource2(rxm, rxa) {
@@ -16988,56 +17016,85 @@ function resource2(rxm, rxa) {
 }
 var gunzipAsync3 = promisify23(gunzip3);
 function format2(rxl) {
-  let result = rxl.domain + "/";
+  let result = "";
+  if (rxl.registry) {
+    result += rxl.registry + "/";
+  }
   if (rxl.path) {
     result += rxl.path + "/";
   }
   result += rxl.name;
-  result += "." + rxl.type;
-  result += "@" + rxl.version;
+  if (rxl.tag && rxl.tag !== "latest") {
+    result += ":" + rxl.tag;
+  }
   return result;
 }
+function looksLikeRegistry2(str) {
+  if (str.includes(":") && !str.includes("/")) {
+    return true;
+  }
+  if (str.includes(".")) {
+    return true;
+  }
+  if (str === "localhost") {
+    return true;
+  }
+  return false;
+}
 function parse2(locator) {
   if (!locator || typeof locator !== "string") {
-    throw new LocatorError2("locator must be a non-empty string", locator);
+    throw new LocatorError2("Locator must be a non-empty string", locator);
   }
-  const atIndex = locator.lastIndexOf("@");
-  if (atIndex === -1) {
-    throw new LocatorError2("locator must contain version (@)", locator);
+  if (locator.includes("@")) {
+    throw new LocatorError2("Invalid locator format. Use name:tag instead of name@version", locator);
   }
-  const version = locator.slice(atIndex + 1);
-  const beforeVersion = locator.slice(0, atIndex);
-  if (!version) {
-    throw new LocatorError2("version is required", locator);
+  const lastSlashIndex = locator.lastIndexOf("/");
+  let beforeSlash = "";
+  let afterSlash = locator;
+  if (lastSlashIndex !== -1) {
+    beforeSlash = locator.substring(0, lastSlashIndex);
+    afterSlash = locator.substring(lastSlashIndex + 1);
   }
-  const dotIndex = beforeVersion.lastIndexOf(".");
-  if (dotIndex === -1) {
-    throw new LocatorError2("locator must contain type (.)", locator);
+  const colonIndex = afterSlash.lastIndexOf(":");
+  let name;
+  let tag;
+  if (colonIndex === -1) {
+    name = afterSlash;
+    tag = "latest";
+  } else {
+    name = afterSlash.substring(0, colonIndex);
+    tag = afterSlash.substring(colonIndex + 1);
   }
-  const type = beforeVersion.slice(dotIndex + 1);
-  const beforeType = beforeVersion.slice(0, dotIndex);
-  if (!type) {
-    throw new LocatorError2("type is required", locator);
+  if (!name) {
+    throw new LocatorError2("Name is required", locator);
   }
-  const parts = beforeType.split("/");
-  if (parts.length < 2) {
-    throw new LocatorError2("locator must contain domain", locator);
+  if (!tag) {
+    throw new LocatorError2("Tag cannot be empty. Use name:tag format or omit tag for :latest", locator);
   }
-  const domain = parts[0];
-  const name = parts[parts.length - 1];
-  const path = parts.length > 2 ? parts.slice(1, -1).join("/") : undefined;
-  if (!domain) {
-    throw new LocatorError2("domain is required", locator);
+  if (lastSlashIndex === -1) {
+    return {
+      registry: undefined,
+      path: undefined,
+      name,
+      tag
+    };
   }
-  if (!name) {
-    throw new LocatorError2("name is required", locator);
+  const parts = beforeSlash.split("/");
+  if (looksLikeRegistry2(parts[0])) {
+    const registry = parts[0];
+    const path = parts.length > 1 ? parts.slice(1).join("/") : undefined;
+    return {
+      registry,
+      path,
+      name,
+      tag
+    };
   }
   return {
-    domain,
-    path,
+    registry: undefined,
+    path: beforeSlash,
     name,
-    type,
-    version
+    tag
   };
 }
 
@@ -17070,20 +17127,18 @@ class RegistryError extends ResourceXError3 {
   }
 }
 
-class HostedRegistry {
+class LocalRegistry {
   storage;
   constructor(storage) {
     this.storage = storage;
   }
   buildKeyPrefix(rxl) {
-    const domain = rxl.domain ?? "localhost";
-    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    const version = rxl.version ?? "latest";
-    let key = domain;
+    const tag = rxl.tag ?? "latest";
+    let key = rxl.name;
     if (rxl.path) {
-      key += `/${rxl.path}`;
+      key = `${rxl.path}/${key}`;
     }
-    key += `/${resourceName}/${version}`;
+    key += `/${tag}`;
     return key;
   }
   async get(rxl) {
@@ -17098,11 +17153,11 @@ class HostedRegistry {
     }
     const manifestJson = JSON.parse(manifestData.toString("utf-8"));
     const rxm = {
-      domain: manifestJson.domain,
+      registry: manifestJson.registry,
       path: manifestJson.path,
       name: manifestJson.name,
       type: manifestJson.type,
-      version: manifestJson.version,
+      tag: manifestJson.tag,
       files: manifestJson.files
     };
     const archiveData = await this.storage.get(archiveKey);
@@ -17114,11 +17169,11 @@ class HostedRegistry {
     const manifestKey = `${prefix}/manifest.json`;
     const archiveKey = `${prefix}/archive.tar.gz`;
     const manifestJson = {
-      domain: rxr2.manifest.domain,
+      registry: rxr2.manifest.registry,
       path: rxr2.manifest.path,
       name: rxr2.manifest.name,
       type: rxr2.manifest.type,
-      version: rxr2.manifest.version,
+      tag: rxr2.manifest.tag,
       files: rxr2.manifest.files
     };
     const manifestData = Buffer.from(JSON.stringify(manifestJson, null, 2), "utf-8");
@@ -17151,7 +17206,7 @@ class HostedRegistry {
     if (query) {
       const lowerQuery = query.toLowerCase();
       filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
+        const searchText = `${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
         return searchText.includes(lowerQuery);
       });
     }
@@ -17164,30 +17219,18 @@ class HostedRegistry {
   parseKeyToRXL(key) {
     const dirPath = key.replace(/\/manifest\.json$/, "");
     const parts = dirPath.split("/");
-    if (parts.length < 3) {
+    if (parts.length < 2) {
       return null;
     }
-    const version = parts.pop();
-    const nameTypePart = parts.pop();
-    const domain = parts.shift();
+    const tag = parts.pop();
+    const name = parts.pop();
     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;
+    let locatorStr = "";
     if (path)
-      locatorStr += `/${path}`;
-    locatorStr += `/${name}`;
-    if (type)
-      locatorStr += `.${type}`;
-    locatorStr += `@${version}`;
+      locatorStr += `${path}/`;
+    locatorStr += name;
+    if (tag !== "latest")
+      locatorStr += `:${tag}`;
     try {
       return parse2(locatorStr);
     } catch {
@@ -17202,14 +17245,13 @@ class MirrorRegistry {
     this.storage = storage;
   }
   buildKeyPrefix(rxl) {
-    const domain = rxl.domain ?? "localhost";
-    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    const version = rxl.version ?? "latest";
-    let key = domain;
+    const registry = rxl.registry ?? "localhost";
+    const tag = rxl.tag ?? "latest";
+    let key = registry;
     if (rxl.path) {
       key += `/${rxl.path}`;
     }
-    key += `/${resourceName}/${version}`;
+    key += `/${rxl.name}/${tag}`;
     return key;
   }
   async get(rxl) {
@@ -17224,11 +17266,11 @@ class MirrorRegistry {
     }
     const manifestJson = JSON.parse(manifestData.toString("utf-8"));
     const rxm = {
-      domain: manifestJson.domain,
+      registry: manifestJson.registry,
       path: manifestJson.path,
       name: manifestJson.name,
       type: manifestJson.type,
-      version: manifestJson.version,
+      tag: manifestJson.tag,
       files: manifestJson.files
     };
     const archiveData = await this.storage.get(archiveKey);
@@ -17240,11 +17282,11 @@ class MirrorRegistry {
     const manifestKey = `${prefix}/manifest.json`;
     const archiveKey = `${prefix}/archive.tar.gz`;
     const manifestJson = {
-      domain: rxr2.manifest.domain,
+      registry: rxr2.manifest.registry,
       path: rxr2.manifest.path,
       name: rxr2.manifest.name,
       type: rxr2.manifest.type,
-      version: rxr2.manifest.version,
+      tag: rxr2.manifest.tag,
       files: rxr2.manifest.files
     };
     const manifestData = Buffer.from(JSON.stringify(manifestJson, null, 2), "utf-8");
@@ -17277,7 +17319,7 @@ class MirrorRegistry {
     if (query) {
       const lowerQuery = query.toLowerCase();
       filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
+        const searchText = `${rxl.registry ?? ""} ${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
         return searchText.includes(lowerQuery);
       });
     }
@@ -17287,22 +17329,22 @@ class MirrorRegistry {
     }
     return result;
   }
-  async clear(domain) {
-    if (domain) {
-      await this.storage.delete(domain);
+  async clear(registry) {
+    if (registry) {
+      await this.storage.delete(registry);
     } else {
       const allKeys = await this.storage.list();
-      const domains = new Set;
+      const registries = new Set;
       for (const key of allKeys) {
         const firstSlash = key.indexOf("/");
         if (firstSlash !== -1) {
-          domains.add(key.substring(0, firstSlash));
+          registries.add(key.substring(0, firstSlash));
         } else {
-          domains.add(key);
+          registries.add(key);
         }
       }
-      for (const d of domains) {
-        await this.storage.delete(d);
+      for (const r of registries) {
+        await this.storage.delete(r);
       }
     }
   }
@@ -17312,27 +17354,16 @@ class MirrorRegistry {
     if (parts.length < 3) {
       return null;
     }
-    const version = parts.pop();
-    const nameTypePart = parts.pop();
-    const domain = parts.shift();
+    const tag = parts.pop();
+    const name = parts.pop();
+    const registry = 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;
+    let locatorStr = registry;
     if (path)
       locatorStr += `/${path}`;
     locatorStr += `/${name}`;
-    if (type)
-      locatorStr += `.${type}`;
-    locatorStr += `@${version}`;
+    if (tag !== "latest")
+      locatorStr += `:${tag}`;
     try {
       return parse2(locatorStr);
     } catch {
@@ -17365,15 +17396,16 @@ function define2(input) {
   if (!obj.type || typeof obj.type !== "string") {
     throw new DefinitionError2("type is required");
   }
-  if (!obj.version || typeof obj.version !== "string") {
-    throw new DefinitionError2("version is required");
+  const tagValue = obj.tag ?? obj.version;
+  if (tagValue !== undefined && typeof tagValue !== "string") {
+    throw new DefinitionError2("tag must be a string");
   }
   const rxd = {
     ...obj,
     name: obj.name,
     type: obj.type,
-    version: obj.version,
-    domain: typeof obj.domain === "string" ? obj.domain : "localhost",
+    tag: typeof tagValue === "string" ? tagValue : undefined,
+    registry: typeof obj.registry === "string" ? obj.registry : undefined,
     path: typeof obj.path === "string" ? obj.path : undefined,
     description: typeof obj.description === "string" ? obj.description : undefined,
     author: typeof obj.author === "string" ? obj.author : undefined,
@@ -17385,11 +17417,11 @@ function define2(input) {
 }
 function manifest2(rxd) {
   return {
-    domain: rxd.domain,
+    registry: rxd.registry,
     path: rxd.path,
     name: rxd.name,
     type: rxd.type,
-    version: rxd.version
+    tag: rxd.tag ?? "latest"
   };
 }
 var BLOCK_SIZE22 = 512;
@@ -17818,11 +17850,10 @@ async function archive2(files2) {
 }
 function locate22(rxm) {
   return {
-    domain: rxm.domain,
+    registry: rxm.registry,
     path: rxm.path,
     name: rxm.name,
-    type: rxm.type,
-    version: rxm.version
+    tag: rxm.tag
   };
 }
 function resource22(rxm, rxa) {
@@ -17906,14 +17937,13 @@ class LinkedRegistry {
     this.basePath = basePath;
   }
   buildLinkPath(rxl) {
-    const domain = rxl.domain ?? "localhost";
-    const resourceName = rxl.type ? `${rxl.name}.${rxl.type}` : rxl.name;
-    const version = rxl.version ?? "latest";
-    let linkPath = join2(this.basePath, domain);
+    const registry = rxl.registry ?? "localhost";
+    const tag = rxl.tag ?? "latest";
+    let linkPath = join2(this.basePath, registry);
     if (rxl.path) {
       linkPath = join2(linkPath, rxl.path);
     }
-    return join2(linkPath, resourceName, version);
+    return join2(linkPath, rxl.name, tag);
   }
   async isSymlink(path) {
     try {
@@ -17956,7 +17986,7 @@ class LinkedRegistry {
     if (query) {
       const lowerQuery = query.toLowerCase();
       filtered = locators.filter((rxl) => {
-        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
+        const searchText = `${rxl.registry ?? ""} ${rxl.path ?? ""} ${rxl.name}`.toLowerCase();
         return searchText.includes(lowerQuery);
       });
     }
@@ -18012,27 +18042,16 @@ class LinkedRegistry {
     if (parts.length < 3) {
       return null;
     }
-    const version = parts.pop();
-    const nameTypePart = parts.pop();
-    const domain = parts.shift();
+    const tag = parts.pop();
+    const name = parts.pop();
+    const registry = 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;
+    let locatorStr = registry;
     if (path)
       locatorStr += `/${path}`;
     locatorStr += `/${name}`;
-    if (type)
-      locatorStr += `.${type}`;
-    locatorStr += `@${version}`;
+    if (tag !== "latest")
+      locatorStr += `:${tag}`;
     try {
       return parse2(locatorStr);
     } catch {
@@ -18041,6 +18060,116 @@ class LinkedRegistry {
   }
 }
 
+class RegistryAccessChain {
+  accessors;
+  memCache = new Map;
+  useMemCache;
+  constructor(accessors, options) {
+    this.accessors = accessors;
+    this.useMemCache = options?.memCache ?? false;
+  }
+  async get(rxl) {
+    const key = format2(rxl);
+    if (this.useMemCache && this.memCache.has(key)) {
+      return this.memCache.get(key);
+    }
+    for (const accessor of this.accessors) {
+      if (await accessor.canHandle(rxl)) {
+        const rxr2 = await accessor.get(rxl);
+        if (this.useMemCache && accessor.name !== "linked") {
+          this.memCache.set(key, rxr2);
+        }
+        return rxr2;
+      }
+    }
+    throw new RegistryError(`Resource not found: ${key}`);
+  }
+  async has(rxl) {
+    const key = format2(rxl);
+    if (this.useMemCache && this.memCache.has(key)) {
+      return true;
+    }
+    for (const accessor of this.accessors) {
+      if (await accessor.canHandle(rxl)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  clearCache() {
+    this.memCache.clear();
+  }
+  invalidate(rxl) {
+    this.memCache.delete(format2(rxl));
+  }
+}
+
+class LinkedAccessor {
+  registry;
+  name = "linked";
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async canHandle(rxl) {
+    return this.registry.has(rxl);
+  }
+  async get(rxl) {
+    return this.registry.get(rxl);
+  }
+}
+
+class LocalAccessor {
+  registry;
+  name = "local";
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async canHandle(rxl) {
+    if (rxl.registry) {
+      return false;
+    }
+    return this.registry.has(rxl);
+  }
+  async get(rxl) {
+    return this.registry.get(rxl);
+  }
+}
+
+class CacheAccessor {
+  registry;
+  name = "cache";
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async canHandle(rxl) {
+    if (!rxl.registry) {
+      return false;
+    }
+    return this.registry.has(rxl);
+  }
+  async get(rxl) {
+    return this.registry.get(rxl);
+  }
+}
+
+class RemoteAccessor {
+  fetcher;
+  cache;
+  name = "remote";
+  constructor(fetcher, cache) {
+    this.fetcher = fetcher;
+    this.cache = cache;
+  }
+  async canHandle(rxl) {
+    return !!rxl.registry;
+  }
+  async get(rxl) {
+    const rxr2 = await this.fetcher.fetch(rxl);
+    await this.cache.put(rxr2);
+    return rxr2;
+  }
+}
+
 // ../loader/dist/index.js
 import { join as join5, relative as relative2 } from "node:path";
 import { stat as stat2, readFile as readFile4, readdir as readdir5 } from "node:fs/promises";
@@ -18073,15 +18202,16 @@ function define3(input) {
   if (!obj.type || typeof obj.type !== "string") {
     throw new DefinitionError3("type is required");
   }
-  if (!obj.version || typeof obj.version !== "string") {
-    throw new DefinitionError3("version is required");
+  const tagValue = obj.tag ?? obj.version;
+  if (tagValue !== undefined && typeof tagValue !== "string") {
+    throw new DefinitionError3("tag must be a string");
   }
   const rxd = {
     ...obj,
     name: obj.name,
     type: obj.type,
-    version: obj.version,
-    domain: typeof obj.domain === "string" ? obj.domain : "localhost",
+    tag: typeof tagValue === "string" ? tagValue : undefined,
+    registry: typeof obj.registry === "string" ? obj.registry : undefined,
     path: typeof obj.path === "string" ? obj.path : undefined,
     description: typeof obj.description === "string" ? obj.description : undefined,
     author: typeof obj.author === "string" ? obj.author : undefined,
@@ -18093,11 +18223,11 @@ function define3(input) {
 }
 function manifest3(rxd) {
   return {
-    domain: rxd.domain,
+    registry: rxd.registry,
     path: rxd.path,
     name: rxd.name,
     type: rxd.type,
-    version: rxd.version
+    tag: rxd.tag ?? "latest"
   };
 }
 var BLOCK_SIZE4 = 512;
@@ -18526,11 +18656,10 @@ async function archive3(files2) {
 }
 function locate3(rxm) {
   return {
-    domain: rxm.domain,
+    registry: rxm.registry,
     path: rxm.path,
     name: rxm.name,
-    type: rxm.type,
-    version: rxm.version
+    tag: rxm.tag
   };
 }
 function resource3(rxm, rxa) {
@@ -18610,21 +18739,34 @@ async function loadResource2(source, config) {
 
 // src/ResourceX.ts
 var DEFAULT_BASE_PATH = `${homedir4()}/.resourcex`;
-var DEFAULT_DOMAIN = "localhost";
+function normalizeRegistryUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname;
+    const port = parsed.port;
+    const protocol = parsed.protocol;
+    const isDefaultPort = protocol === "http:" && (port === "" || port === "80") || protocol === "https:" && (port === "" || port === "443");
+    if (isDefaultPort || !port) {
+      return host;
+    }
+    return `${host}:${port}`;
+  } catch {
+    return url;
+  }
+}
 
 class DefaultResourceX {
   basePath;
-  domain;
-  registry;
+  registryUrl;
   typeHandler;
   isolator;
-  hosted;
+  local;
   cache;
   linked;
+  chain;
   constructor(config2) {
     this.basePath = config2?.path ?? DEFAULT_BASE_PATH;
-    this.domain = config2?.domain ?? DEFAULT_DOMAIN;
-    this.registry = config2?.registry;
+    this.registryUrl = config2?.registry;
     this.isolator = config2?.isolator ?? "none";
     this.typeHandler = TypeHandlerChain.create();
     if (config2?.types) {
@@ -18632,61 +18774,125 @@ class DefaultResourceX {
         this.typeHandler.register(type);
       }
     }
-    const hostedStorage = new FileSystemStorage(join9(this.basePath, "hosted"));
+    const localStorage = new FileSystemStorage(join9(this.basePath, "local"));
     const cacheStorage = new FileSystemStorage(join9(this.basePath, "cache"));
-    this.hosted = new HostedRegistry(hostedStorage);
+    this.local = new LocalRegistry(localStorage);
     this.cache = new MirrorRegistry(cacheStorage);
     this.linked = new LinkedRegistry(join9(this.basePath, "linked"));
-  }
-  normalizeLocator(locator) {
-    const atIndex = locator.indexOf("@");
-    const slashIndex = locator.indexOf("/");
-    if (slashIndex !== -1 && (atIndex === -1 || slashIndex < atIndex)) {
-      return locator;
+    const accessors = [
+      new LinkedAccessor(this.linked),
+      new LocalAccessor(this.local),
+      new CacheAccessor(this.cache)
+    ];
+    if (this.registryUrl) {
+      const fetcher = this.createRemoteFetcher();
+      accessors.push(new RemoteAccessor(fetcher, this.cache));
     }
-    return `${this.domain}/${locator}`;
+    this.chain = new RegistryAccessChain(accessors);
+  }
+  createRemoteFetcher() {
+    const registryUrl = this.registryUrl;
+    const normalizedRegistry = normalizeRegistryUrl(registryUrl);
+    return {
+      fetch: async (rxl) => this.fetchFromRegistry(format(rxl), registryUrl, normalizedRegistry)
+    };
+  }
+  toResource(rxr2) {
+    return {
+      locator: format(rxr2.locator),
+      registry: rxr2.manifest.registry,
+      path: rxr2.manifest.path,
+      name: rxr2.manifest.name,
+      type: rxr2.manifest.type,
+      tag: rxr2.manifest.tag,
+      files: rxr2.manifest.files
+    };
   }
   async add(path11) {
     const rxr2 = await loadResource2(path11);
-    if (!rxr2.manifest.domain || rxr2.manifest.domain === "localhost") {
+    if (rxr2.manifest.registry) {
       const { manifest: createManifest, resource: createResource } = await Promise.resolve().then(() => (init_dist(), exports_dist));
       const newManifest = createManifest({
-        domain: this.domain,
+        registry: undefined,
         path: rxr2.manifest.path,
         name: rxr2.manifest.name,
         type: rxr2.manifest.type,
-        version: rxr2.manifest.version
+        version: rxr2.manifest.tag
       });
       const newRxr = createResource(newManifest, rxr2.archive);
-      await this.hosted.put(newRxr);
-    } else {
-      await this.hosted.put(rxr2);
+      await this.local.put(newRxr);
+      return this.toResource(newRxr);
     }
+    await this.local.put(rxr2);
+    return this.toResource(rxr2);
   }
   async link(path11) {
     await this.linked.link(path11);
   }
+  async unlink(locator) {
+    const rxl = parse(locator);
+    await this.linked.unlink(rxl);
+    this.chain.invalidate(rxl);
+  }
   async has(locator) {
-    const normalizedLocator = this.normalizeLocator(locator);
-    const rxl = parse(normalizedLocator);
-    return await this.linked.has(rxl) || await this.hosted.has(rxl) || await this.cache.has(rxl);
+    const rxl = parse(locator);
+    return this.chain.has(rxl);
+  }
+  async info(locator) {
+    const rxl = parse(locator);
+    const rxr2 = await this.chain.get(rxl);
+    const filesRecord2 = await extract(rxr2.archive);
+    const files2 = Object.keys(filesRecord2);
+    return {
+      locator: format(rxr2.locator),
+      registry: rxr2.manifest.registry,
+      path: rxr2.manifest.path,
+      name: rxr2.manifest.name,
+      type: rxr2.manifest.type,
+      tag: rxr2.manifest.tag,
+      files: files2
+    };
   }
   async remove(locator) {
-    const normalizedLocator = this.normalizeLocator(locator);
-    const rxl = parse(normalizedLocator);
+    const rxl = parse(locator);
     if (await this.linked.has(rxl)) {
       await this.linked.remove(rxl);
     }
-    if (await this.hosted.has(rxl)) {
-      await this.hosted.remove(rxl);
+    if (!rxl.registry && await this.local.has(rxl)) {
+      await this.local.remove(rxl);
     }
-    if (await this.cache.has(rxl)) {
+    if (rxl.registry && await this.cache.has(rxl)) {
       await this.cache.remove(rxl);
     }
+    this.chain.invalidate(rxl);
   }
-  async resolve(locator) {
-    const normalizedLocator = this.normalizeLocator(locator);
-    const rxr2 = await this.getRxr(normalizedLocator);
+  async use(locator) {
+    const rxl = parse(locator);
+    let rxr2;
+    try {
+      rxr2 = await this.chain.get(rxl);
+    } catch (error) {
+      if (!rxl.registry && this.registryUrl) {
+        const normalizedRegistry = normalizeRegistryUrl(this.registryUrl);
+        try {
+          rxr2 = await this.fetchFromRegistry(format(rxl), this.registryUrl, normalizedRegistry);
+          await this.cache.put(rxr2);
+        } catch {
+          throw error;
+        }
+      } else if (rxl.registry) {
+        const registryUrl = `http://${rxl.registry}`;
+        const locatorWithoutRegistry = format({ ...rxl, registry: undefined });
+        try {
+          rxr2 = await this.fetchFromRegistry(locatorWithoutRegistry, registryUrl, rxl.registry);
+          await this.cache.put(rxr2);
+        } catch {
+          throw error;
+        }
+      } else {
+        throw error;
+      }
+    }
     const handler = this.typeHandler.getHandler(rxr2.manifest.type);
     return {
       schema: handler.schema,
@@ -18697,14 +18903,14 @@ class DefaultResourceX {
   }
   async search(query) {
     const options = query ? { query } : undefined;
-    const [linkedResults, hostedResults, cacheResults] = await Promise.all([
+    const [linkedResults, localResults, cacheResults] = await Promise.all([
       this.linked.list(options),
-      this.hosted.list(options),
+      this.local.list(options),
       this.cache.list(options)
     ]);
     const seen = new Set;
     const results = [];
-    for (const rxl of [...linkedResults, ...hostedResults, ...cacheResults]) {
+    for (const rxl of [...linkedResults, ...localResults, ...cacheResults]) {
       const key = format(rxl);
       if (!seen.has(key)) {
         seen.add(key);
@@ -18713,63 +18919,40 @@ class DefaultResourceX {
     }
     return results;
   }
-  async push(path11) {
-    if (!this.registry) {
+  async push(locator) {
+    if (!this.registryUrl) {
       throw new RegistryError("Registry URL not configured. Set 'registry' in config.");
     }
-    const rxr2 = await loadResource2(path11);
-    const { manifest: createManifest, resource: createResource } = await Promise.resolve().then(() => (init_dist(), exports_dist));
-    const newManifest = createManifest({
-      domain: this.domain,
-      path: rxr2.manifest.path,
-      name: rxr2.manifest.name,
-      type: rxr2.manifest.type,
-      version: rxr2.manifest.version
-    });
-    const newRxr = createResource(newManifest, rxr2.archive);
-    await this.publishToRegistry(newRxr);
+    const rxl = parse(locator);
+    const rxr2 = await this.chain.get(rxl);
+    await this.publishToRegistry(rxr2);
   }
   async pull(locator) {
-    if (!this.registry) {
+    if (!this.registryUrl) {
       throw new RegistryError("Registry URL not configured. Set 'registry' in config.");
     }
-    const normalizedLocator = this.normalizeLocator(locator);
-    const rxr2 = await this.fetchFromRegistry(normalizedLocator);
+    const normalizedRegistry = normalizeRegistryUrl(this.registryUrl);
+    const rxr2 = await this.fetchFromRegistry(locator, this.registryUrl, normalizedRegistry);
     await this.cache.put(rxr2);
   }
+  async clearCache(registry) {
+    await this.cache.clear(registry);
+  }
   supportType(type) {
     this.typeHandler.register(type);
   }
-  async getRxr(locator) {
-    const rxl = parse(locator);
-    if (await this.linked.has(rxl)) {
-      return this.linked.get(rxl);
-    }
-    if (await this.hosted.has(rxl)) {
-      return this.hosted.get(rxl);
-    }
-    if (await this.cache.has(rxl)) {
-      return this.cache.get(rxl);
-    }
-    if (this.registry) {
-      const rxr2 = await this.fetchFromRegistry(locator);
-      await this.cache.put(rxr2);
-      return rxr2;
-    }
-    throw new RegistryError(`Resource not found: ${locator}`);
-  }
   async publishToRegistry(rxr2) {
-    const baseUrl = this.registry.replace(/\/$/, "");
-    const publishUrl = `${baseUrl}/publish`;
+    const baseUrl = this.registryUrl.replace(/\/$/, "");
+    const publishUrl = `${baseUrl}/api/v1/publish`;
     const formData = new FormData;
     formData.append("locator", format(rxr2.locator));
     formData.append("manifest", new Blob([
       JSON.stringify({
-        domain: rxr2.manifest.domain,
+        registry: rxr2.manifest.registry,
         path: rxr2.manifest.path,
         name: rxr2.manifest.name,
         type: rxr2.manifest.type,
-        version: rxr2.manifest.version
+        version: rxr2.manifest.tag
       })
     ], { type: "application/json" }));
     const archiveBuffer = await rxr2.archive.buffer();
@@ -18782,9 +18965,10 @@ class DefaultResourceX {
       throw new RegistryError(`Failed to publish: ${response.statusText}`);
     }
   }
-  async fetchFromRegistry(locator) {
-    const baseUrl = this.registry.replace(/\/$/, "");
-    const manifestUrl = `${baseUrl}/resource/${encodeURIComponent(locator)}`;
+  async fetchFromRegistry(locator, registryUrl, normalizedRegistry) {
+    const baseUrl = registryUrl.replace(/\/$/, "");
+    const registry = normalizedRegistry ?? normalizeRegistryUrl(registryUrl);
+    const manifestUrl = `${baseUrl}/api/v1/resource/${encodeURIComponent(locator)}`;
     const manifestResponse = await fetch(manifestUrl);
     if (!manifestResponse.ok) {
       if (manifestResponse.status === 404) {
@@ -18799,13 +18983,13 @@ class DefaultResourceX {
       resource: createResource
     } = await Promise.resolve().then(() => (init_dist(), exports_dist));
     const rxm = createManifest({
-      domain: manifestData.domain,
+      registry,
       path: manifestData.path,
       name: manifestData.name,
       type: manifestData.type,
-      version: manifestData.version
+      tag: manifestData.tag
     });
-    const contentUrl = `${baseUrl}/content/${encodeURIComponent(locator)}`;
+    const contentUrl = `${baseUrl}/api/v1/content/${encodeURIComponent(locator)}`;
     const contentResponse = await fetch(contentUrl);
     if (!contentResponse.ok) {
       throw new RegistryError(`Failed to fetch content: ${contentResponse.statusText}`);
@@ -18822,11 +19006,11 @@ class DefaultResourceX {
     }
     const context = {
       manifest: {
-        domain: rxr.manifest.domain,
+        registry: rxr.manifest.registry,
         path: rxr.manifest.path,
         name: rxr.manifest.name,
         type: rxr.manifest.type,
-        version: rxr.manifest.version
+        version: rxr.manifest.tag
       },
       files
     };
@@ -18872,13 +19056,21 @@ function createResourceX2(config2) {
 }
 
 // src/index.ts
-var VERSION = "2.5.0";
+init_dist();
+var VERSION = "2.5.2";
 export {
+  wrap,
+  resource,
+  parse,
+  manifest,
+  format,
+  extract,
   createResourceX2 as createResourceX,
   bundleResourceType,
+  archive,
   VERSION,
   ResourceTypeError,
   RegistryError
 };
 
-//# debugId=2AD1F4EBBAD17C8564756E2164756E21
+//# debugId=D7A402F2FA14E9CA64756E2164756E21