@resourcexjs/cli 2.18.0 → 2.20.0

package/dist/index.js

@@ -774,18 +774,394 @@ var init_prompt = __esm(() => {
 });
 
 // ../../packages/core/dist/index.js
-import { promisify } from "util";
-import { gzip } from "zlib";
-import { promisify as promisify2 } from "util";
-import { gunzip } from "zlib";
-import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
-import { join as join2, relative as relative2 } from "path";
-import { dirname, join as join3 } from "path";
-import { fileURLToPath, pathToFileURL } from "url";
-import { createHash } from "crypto";
 function __exportSetter2(name, newValue) {
   this[name] = __returnValue2.bind(null, newValue);
 }
+function writeString(view, offset, size, value) {
+  if (value)
+    encoder.encodeInto(value, view.subarray(offset, offset + size));
+}
+function writeOctal(view, offset, size, value) {
+  if (value === undefined)
+    return;
+  const octalString = value.toString(8).padStart(size - 1, "0");
+  encoder.encodeInto(octalString, view.subarray(offset, offset + size - 1));
+}
+async function normalizeBody(body) {
+  if (body === null || body === undefined)
+    return EMPTY;
+  if (body instanceof Uint8Array)
+    return body;
+  if (typeof body === "string")
+    return encoder.encode(body);
+  if (body instanceof ArrayBuffer)
+    return new Uint8Array(body);
+  if (body instanceof Blob)
+    return new Uint8Array(await body.arrayBuffer());
+  throw new TypeError("Unsupported content type for entry body.");
+}
+function 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 i2 = USTAR_CHECKSUM_OFFSET + 6 - 1;i2 >= USTAR_CHECKSUM_OFFSET; i2--) {
+    block[i2] = (checksum & 7) + ASCII_ZERO;
+    checksum >>= 3;
+  }
+  block[USTAR_CHECKSUM_OFFSET + 6] = 0;
+  block[USTAR_CHECKSUM_OFFSET + 7] = CHECKSUM_SPACE;
+}
+function generatePax(header) {
+  const paxRecords = {};
+  if (header.name.length > USTAR_NAME_SIZE) {
+    if (findUstarSplit(header.name) === null)
+      paxRecords.path = header.name;
+  }
+  if (header.linkname && header.linkname.length > USTAR_NAME_SIZE)
+    paxRecords.linkpath = header.linkname;
+  if (header.uname && header.uname.length > USTAR_UNAME_SIZE)
+    paxRecords.uname = header.uname;
+  if (header.gname && header.gname.length > USTAR_GNAME_SIZE)
+    paxRecords.gname = header.gname;
+  if (header.uid != null && header.uid > USTAR_MAX_UID_GID)
+    paxRecords.uid = String(header.uid);
+  if (header.gid != null && header.gid > USTAR_MAX_UID_GID)
+    paxRecords.gid = String(header.gid);
+  if (header.size != null && header.size > USTAR_MAX_SIZE)
+    paxRecords.size = String(header.size);
+  if (header.pax)
+    Object.assign(paxRecords, header.pax);
+  const paxEntries = Object.entries(paxRecords);
+  if (paxEntries.length === 0)
+    return null;
+  const paxBody = encoder.encode(paxEntries.map(([key, value]) => {
+    const record = `${key}=${value}
+`;
+    const partLength = encoder.encode(record).length + 1;
+    let totalLength = partLength + String(partLength).length;
+    totalLength = partLength + String(totalLength).length;
+    return `${totalLength} ${record}`;
+  }).join(""));
+  return {
+    paxHeader: createTarHeader({
+      name: decoder.decode(encoder.encode(`PaxHeader/${header.name}`).slice(0, 100)),
+      size: paxBody.length,
+      type: "pax-header",
+      mode: 420,
+      mtime: header.mtime,
+      uname: header.uname,
+      gname: header.gname,
+      uid: header.uid,
+      gid: header.gid
+    }),
+    paxBody
+  };
+}
+function findUstarSplit(path) {
+  if (path.length <= USTAR_NAME_SIZE)
+    return null;
+  const minSlashIndex = path.length - USTAR_NAME_SIZE - 1;
+  const slashIndex = path.lastIndexOf("/", USTAR_PREFIX_SIZE);
+  if (slashIndex > 0 && slashIndex >= minSlashIndex)
+    return {
+      prefix: path.slice(0, slashIndex),
+      name: path.slice(slashIndex + 1)
+    };
+  return null;
+}
+function createTarHeader(header) {
+  const view = new Uint8Array(BLOCK_SIZE);
+  const size = isBodyless(header) ? 0 : header.size ?? 0;
+  let name = header.name;
+  let prefix = "";
+  if (!header.pax?.path) {
+    const split = findUstarSplit(name);
+    if (split) {
+      name = split.name;
+      prefix = split.prefix;
+    }
+  }
+  writeString(view, USTAR_NAME_OFFSET, USTAR_NAME_SIZE, name);
+  writeOctal(view, USTAR_MODE_OFFSET, USTAR_MODE_SIZE, header.mode ?? (header.type === DIRECTORY ? DEFAULT_DIR_MODE : DEFAULT_FILE_MODE));
+  writeOctal(view, USTAR_UID_OFFSET, USTAR_UID_SIZE, header.uid ?? 0);
+  writeOctal(view, USTAR_GID_OFFSET, USTAR_GID_SIZE, header.gid ?? 0);
+  writeOctal(view, USTAR_SIZE_OFFSET, USTAR_SIZE_SIZE, size);
+  writeOctal(view, USTAR_MTIME_OFFSET, USTAR_MTIME_SIZE, Math.floor((header.mtime?.getTime() ?? Date.now()) / 1000));
+  writeString(view, USTAR_TYPEFLAG_OFFSET, USTAR_TYPEFLAG_SIZE, TYPEFLAG[header.type ?? FILE]);
+  writeString(view, USTAR_LINKNAME_OFFSET, USTAR_LINKNAME_SIZE, header.linkname);
+  writeString(view, USTAR_MAGIC_OFFSET, USTAR_MAGIC_SIZE, "ustar\x00");
+  writeString(view, USTAR_VERSION_OFFSET, USTAR_VERSION_SIZE, USTAR_VERSION);
+  writeString(view, USTAR_UNAME_OFFSET, USTAR_UNAME_SIZE, header.uname);
+  writeString(view, USTAR_GNAME_OFFSET, USTAR_GNAME_SIZE, header.gname);
+  writeString(view, USTAR_PREFIX_OFFSET, USTAR_PREFIX_SIZE, prefix);
+  writeChecksum(view);
+  return view;
+}
+function getHeaderBlocks(header) {
+  const base = createTarHeader(header);
+  const pax = generatePax(header);
+  if (!pax)
+    return [base];
+  const paxPadding = -pax.paxBody.length & BLOCK_SIZE_MASK;
+  const paddingBlocks = paxPadding > 0 ? [ZERO_BLOCK.subarray(0, paxPadding)] : [];
+  return [
+    pax.paxHeader,
+    pax.paxBody,
+    ...paddingBlocks,
+    base
+  ];
+}
+function createTarPacker(onData, onError, onFinalize) {
+  let currentHeader = null;
+  let bytesWritten = 0;
+  let finalized = false;
+  return {
+    add(header) {
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("No new tar entries after finalize.");
+        onError(error);
+        throw error;
+      }
+      if (currentHeader !== null) {
+        const error = /* @__PURE__ */ new Error("Previous entry must be completed before adding a new one");
+        onError(error);
+        throw error;
+      }
+      try {
+        const size = isBodyless(header) ? 0 : header.size ?? 0;
+        const headerBlocks = getHeaderBlocks({
+          ...header,
+          size
+        });
+        for (const block of headerBlocks)
+          onData(block);
+        currentHeader = {
+          ...header,
+          size
+        };
+        bytesWritten = 0;
+      } catch (error) {
+        onError(error);
+      }
+    },
+    write(chunk) {
+      if (!currentHeader) {
+        const error = /* @__PURE__ */ new Error("No active tar entry.");
+        onError(error);
+        throw error;
+      }
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("Cannot write data after finalize.");
+        onError(error);
+        throw error;
+      }
+      const newTotal = bytesWritten + chunk.length;
+      if (newTotal > currentHeader.size) {
+        const error = /* @__PURE__ */ new Error(`"${currentHeader.name}" exceeds given size of ${currentHeader.size} bytes.`);
+        onError(error);
+        throw error;
+      }
+      try {
+        bytesWritten = newTotal;
+        onData(chunk);
+      } catch (error) {
+        onError(error);
+      }
+    },
+    endEntry() {
+      if (!currentHeader) {
+        const error = /* @__PURE__ */ new Error("No active entry to end.");
+        onError(error);
+        throw error;
+      }
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("Cannot end entry after finalize.");
+        onError(error);
+        throw error;
+      }
+      try {
+        if (bytesWritten !== currentHeader.size) {
+          const error = /* @__PURE__ */ new Error(`Size mismatch for "${currentHeader.name}".`);
+          onError(error);
+          throw error;
+        }
+        const paddingSize = -currentHeader.size & BLOCK_SIZE_MASK;
+        if (paddingSize > 0)
+          onData(new Uint8Array(paddingSize));
+        currentHeader = null;
+        bytesWritten = 0;
+      } catch (error) {
+        onError(error);
+        throw error;
+      }
+    },
+    finalize() {
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("Archive has already been finalized");
+        onError(error);
+        throw error;
+      }
+      if (currentHeader !== null) {
+        const error = /* @__PURE__ */ new Error("Cannot finalize while an entry is still active");
+        onError(error);
+        throw error;
+      }
+      try {
+        onData(EOF_BUFFER);
+        finalized = true;
+        if (onFinalize)
+          onFinalize();
+      } catch (error) {
+        onError(error);
+      }
+    }
+  };
+}
+function 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 h2 = { ...header };
+        if (bodyless)
+          h2.size = 0;
+        packer.add(h2);
+        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();
+  }
+}
+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 gzipCompress(data) {
+  const cs = new CompressionStream("gzip");
+  const writer = cs.writable.getWriter();
+  writer.write(data);
+  writer.close();
+  const reader = cs.readable.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+  }
+  const totalLength = chunks.reduce((sum, c3) => sum + c3.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return Buffer.from(result);
+}
+
+class RXAImpl {
+  _buffer;
+  constructor(buffer) {
+    this._buffer = buffer;
+  }
+  get stream() {
+    const buffer = this._buffer;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(buffer));
+        controller.close();
+      }
+    });
+  }
+  async buffer() {
+    return this._buffer;
+  }
+}
+async function archive(files) {
+  const entries = Object.entries(files).map(([name, content]) => {
+    return {
+      header: { name, size: content.length, type: "file" },
+      body: new Uint8Array(content)
+    };
+  });
+  const tarBuffer = await packTar(entries);
+  const gzipBuffer = await gzipCompress(new Uint8Array(tarBuffer));
+  return new RXAImpl(gzipBuffer);
+}
 function $constructor(name, initializer, params) {
   function init2(inst, def) {
     if (!inst._zod) {
@@ -4473,72 +4849,215 @@ function bigint3(params) {
 function date4(params) {
   return _coercedDate(ZodDate, params);
 }
-
-class FolderSourceLoader {
-  async canLoad(source) {
-    try {
-      const stats = await stat2(source);
-      return stats.isDirectory();
-    } catch {
-      return false;
-    }
+function define(input) {
+  if (input === null || typeof input !== "object") {
+    throw new DefinitionError("definition must be an object");
   }
-  async load(source) {
-    const canLoad = await this.canLoad(source);
-    if (!canLoad) {
-      throw new ResourceXError(`Source is not a directory: ${source}`);
-    }
-    const files = await this.readFolderFiles(source);
-    return { source, files };
+  let validated;
+  try {
+    validated = RXDSchema.parse(input);
+  } catch (e2) {
+    throw new DefinitionError(`Invalid definition: ${e2 instanceof Error ? e2.message : String(e2)}`);
+  }
+  const rxd = Object.assign(Object.create(null), {
+    name: validated.name,
+    type: validated.type,
+    tag: validated.tag ?? undefined,
+    registry: validated.registry,
+    path: validated.path,
+    description: validated.description,
+    author: validated.author,
+    license: validated.license,
+    keywords: validated.keywords,
+    repository: validated.repository
+  });
+  return rxd;
+}
+function format(rxi) {
+  let result = "";
+  if (rxi.registry) {
+    result += `${rxi.registry}/`;
+  }
+  if (rxi.path) {
+    result += `${rxi.path}/`;
+  }
+  result += rxi.name;
+  if (rxi.tag && rxi.tag !== "latest") {
+    result += `:${rxi.tag}`;
+  }
+  if (rxi.digest) {
+    result += `@${rxi.digest}`;
   }
-  async readFolderFiles(folderPath, basePath = folderPath) {
-    const files = {};
-    const entries = await readdir2(folderPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join2(folderPath, entry.name);
-      const relativePath = relative2(basePath, fullPath);
-      if (entry.isFile()) {
-        files[relativePath] = await readFile2(fullPath);
-      } else if (entry.isDirectory()) {
-        const subFiles = await this.readFolderFiles(fullPath, basePath);
-        Object.assign(files, subFiles);
+  return result;
+}
+function locate(rxm) {
+  return {
+    registry: rxm.definition.registry,
+    path: rxm.definition.path,
+    name: rxm.definition.name,
+    tag: rxm.definition.tag
+  };
+}
+function manifest(rxd) {
+  return {
+    definition: {
+      name: rxd.name,
+      type: rxd.type,
+      tag: rxd.tag ?? "latest",
+      registry: rxd.registry,
+      path: rxd.path,
+      description: rxd.description,
+      author: rxd.author,
+      license: rxd.license,
+      keywords: rxd.keywords,
+      repository: rxd.repository
+    },
+    archive: {},
+    source: {}
+  };
+}
+function validateLocatorSecurity(locator) {
+  if (locator.length > MAX_LOCATOR_LENGTH) {
+    throw new LocatorError("Locator too long", locator);
+  }
+  if (locator.startsWith("/") || locator.startsWith("\\")) {
+    throw new LocatorError("Absolute paths not allowed", locator);
+  }
+  const normalized = locator.normalize("NFC");
+  let decoded;
+  try {
+    decoded = decodeURIComponent(normalized);
+  } catch {
+    decoded = normalized;
+  }
+  const lastColonIndex = decoded.lastIndexOf(":");
+  const namePathPart = lastColonIndex !== -1 ? decoded.substring(0, lastColonIndex) : decoded;
+  if (namePathPart.includes("..")) {
+    throw new LocatorError("Path traversal detected", locator);
+  }
+  const segments = decoded.split("/");
+  const stack = [];
+  for (const seg of segments) {
+    if (seg === "..") {
+      if (stack.length > 0)
+        stack.pop();
+      else {
+        throw new LocatorError("Path traversal detected", locator);
       }
+    } else if (seg !== "." && seg !== "") {
+      stack.push(seg);
     }
-    return files;
+  }
+  const pathNormalized = stack.join("/");
+  if (pathNormalized.startsWith("/") || pathNormalized.startsWith("\\")) {
+    throw new LocatorError("Path traversal detected", locator);
+  }
+  if (DANGEROUS_PATTERNS.test(decoded)) {
+    throw new LocatorError("Invalid characters detected", locator);
   }
 }
-
-class NpmSourceLoader {
-  folder = new FolderSourceLoader;
-  canLoad(source) {
-    return source.startsWith(NPM_PREFIX);
+function looksLikeRegistry(str) {
+  if (str.includes(":") && !str.includes("/")) {
+    return true;
   }
-  async load(source) {
-    if (!this.canLoad(source)) {
-      throw new ResourceXError(`Not an npm source: ${source}`);
+  if (str.includes(".")) {
+    return true;
+  }
+  if (str === "localhost") {
+    return true;
+  }
+  return false;
+}
+function parse5(locator) {
+  if (!locator || typeof locator !== "string") {
+    throw new LocatorError("Locator must be a non-empty string", locator);
+  }
+  validateLocatorSecurity(locator);
+  let digest;
+  let locatorWithoutDigest = locator;
+  const atIndex = locator.indexOf("@");
+  if (atIndex !== -1) {
+    if (atIndex === 0) {
+      throw new LocatorError("Invalid locator format. Name is required before @", locator);
     }
-    const packageName = source.slice(NPM_PREFIX.length);
-    if (!packageName) {
-      throw new ResourceXError(`Empty package name in npm source: ${source}`);
+    digest = locator.substring(atIndex + 1);
+    locatorWithoutDigest = locator.substring(0, atIndex);
+    if (!digest || digest.includes("@")) {
+      throw new LocatorError("Invalid digest format after @", locator);
     }
-    const packageDir = this.resolvePackageDir(packageName);
-    const rxs = await this.folder.load(packageDir);
-    return { source, files: rxs.files };
   }
-  resolvePackageDir(packageName) {
-    const entry = globalThis.Bun?.main ?? process.argv[1] ?? join3(process.cwd(), "noop.js");
-    const parent = pathToFileURL(entry).href;
-    try {
-      const url2 = import.meta.resolve(`${packageName}/package.json`, parent);
-      return dirname(fileURLToPath(url2));
-    } catch {
-      throw new ResourceXError(`Cannot resolve npm package: ${packageName}`);
-    }
+  const lastSlashIndex = locatorWithoutDigest.lastIndexOf("/");
+  let beforeSlash = "";
+  let afterSlash = locatorWithoutDigest;
+  if (lastSlashIndex !== -1) {
+    beforeSlash = locatorWithoutDigest.substring(0, lastSlashIndex);
+    afterSlash = locatorWithoutDigest.substring(lastSlashIndex + 1);
+  }
+  const colonIndex = afterSlash.lastIndexOf(":");
+  let name;
+  let tag;
+  if (colonIndex === -1) {
+    name = afterSlash;
+    tag = "latest";
+  } else {
+    name = afterSlash.substring(0, colonIndex);
+    tag = afterSlash.substring(colonIndex + 1);
+  }
+  if (!name) {
+    throw new LocatorError("Name is required", locator);
+  }
+  if (!tag) {
+    throw new LocatorError("Tag cannot be empty. Use name:tag format or omit tag for :latest", locator);
+  }
+  if (lastSlashIndex === -1) {
+    return {
+      registry: undefined,
+      path: undefined,
+      name,
+      tag,
+      digest
+    };
+  }
+  const parts = beforeSlash.split("/");
+  if (looksLikeRegistry(parts[0])) {
+    const registry2 = parts[0];
+    const path = parts.length > 1 ? parts.slice(1).join("/") : undefined;
+    return {
+      registry: registry2,
+      path,
+      name,
+      tag,
+      digest
+    };
   }
+  return {
+    registry: undefined,
+    path: beforeSlash,
+    name,
+    tag,
+    digest
+  };
+}
+function resource(rxm, rxa) {
+  const rxi = locate(rxm);
+  return {
+    identifier: rxi,
+    manifest: rxm,
+    archive: rxa
+  };
 }
-function computeDigest(data) {
-  const hash2 = createHash("sha256").update(data).digest("hex");
-  return `sha256:${hash2}`;
+async function loadResource(source, config2) {
+  const loader = config2.loader;
+  const canLoad = await loader.canLoad(source);
+  if (!canLoad) {
+    throw new ResourceXError(`Cannot load resource from: ${source}`);
+  }
+  return loader.load(source);
+}
+async function computeDigest(data) {
+  const hash2 = await crypto.subtle.digest("SHA-256", data);
+  const hex3 = [...new Uint8Array(hash2)].map((b2) => b2.toString(16).padStart(2, "0")).join("");
+  return `sha256:${hex3}`;
 }
 function isValidDigest(digest) {
   return /^sha256:[a-f0-9]{64}$/.test(digest);
@@ -4554,7 +5073,7 @@ class MemoryRXAStore {
     return blob;
   }
   async put(data) {
-    const digest = computeDigest(data);
+    const digest = await computeDigest(data);
     if (!this.blobs.has(digest)) {
       this.blobs.set(digest, data);
     }
@@ -4720,7 +5239,7 @@ var __defProp2, __returnValue2 = (v2) => v2, __export2 = (target, all) => {
       configurable: true,
       set: __exportSetter2.bind(all, name)
     });
-}, BLOCK_SIZE = 512, ZERO_BLOCK, EMPTY, encoder, decoder, EOF_BUFFER, gzipAsync, exports_external, exports_core2, NEVER, $brand, $ZodAsyncError, $ZodEncodeError, globalConfig, exports_util, EVALUATING, captureStackTrace, allowsEval, getParsedType = (data) => {
+}, BLOCK_SIZE = 512, BLOCK_SIZE_MASK = 511, DEFAULT_FILE_MODE = 420, DEFAULT_DIR_MODE = 493, USTAR_NAME_OFFSET = 0, USTAR_NAME_SIZE = 100, USTAR_MODE_OFFSET = 100, USTAR_MODE_SIZE = 8, USTAR_UID_OFFSET = 108, USTAR_UID_SIZE = 8, USTAR_GID_OFFSET = 116, USTAR_GID_SIZE = 8, USTAR_SIZE_OFFSET = 124, USTAR_SIZE_SIZE = 12, USTAR_MTIME_OFFSET = 136, USTAR_MTIME_SIZE = 12, USTAR_CHECKSUM_OFFSET = 148, USTAR_CHECKSUM_SIZE = 8, USTAR_TYPEFLAG_OFFSET = 156, USTAR_TYPEFLAG_SIZE = 1, USTAR_LINKNAME_OFFSET = 157, USTAR_LINKNAME_SIZE = 100, USTAR_MAGIC_OFFSET = 257, USTAR_MAGIC_SIZE = 6, USTAR_VERSION_OFFSET = 263, USTAR_VERSION_SIZE = 2, USTAR_UNAME_OFFSET = 265, USTAR_UNAME_SIZE = 32, USTAR_GNAME_OFFSET = 297, USTAR_GNAME_SIZE = 32, USTAR_PREFIX_OFFSET = 345, USTAR_PREFIX_SIZE = 155, USTAR_VERSION = "00", USTAR_MAX_UID_GID = 2097151, USTAR_MAX_SIZE = 8589934591, FILE = "file", LINK = "link", SYMLINK = "symlink", DIRECTORY = "directory", TYPEFLAG, ZERO_BLOCK, EMPTY, encoder, decoder, isBodyless = (header) => header.type === DIRECTORY || header.type === SYMLINK || header.type === LINK, CHECKSUM_SPACE = 32, ASCII_ZERO = 48, EOF_BUFFER, exports_external, exports_core2, NEVER, $brand, $ZodAsyncError, $ZodEncodeError, globalConfig, exports_util, EVALUATING, captureStackTrace, allowsEval, getParsedType = (data) => {
   const t2 = typeof data;
   switch (t2) {
     case "undefined":
@@ -10398,15 +10917,27 @@ var __defProp2, __returnValue2 = (v2) => v2, __export2 = (target, all) => {
   Codec: ZodCodec,
   Boolean: ZodBoolean,
   String: ZodString
-}, ...args), ZodIssueCode, ZodFirstPartyTypeKind, z2, RECOGNIZED_KEYS, exports_coerce, ResourceXError, RXDSchema, gunzipAsync, NPM_PREFIX = "npm:", RegistryError, textType, jsonType, binaryType, skillType, prototypeType, builtinTypes, ResourceTypeError;
+}, ...args), ZodIssueCode, ZodFirstPartyTypeKind, z2, RECOGNIZED_KEYS, exports_coerce, ResourceXError, LocatorError, DefinitionError, RXDSchema, MAX_LOCATOR_LENGTH = 256, DANGEROUS_PATTERNS, RegistryError, textType, jsonType, binaryType, skillType, prototypeType, builtinTypes, ResourceTypeError;
 var init_dist = __esm(() => {
   __defProp2 = Object.defineProperty;
+  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"
+  };
   ZERO_BLOCK = new Uint8Array(BLOCK_SIZE);
   EMPTY = new Uint8Array(0);
   encoder = new TextEncoder;
   decoder = new TextDecoder;
   EOF_BUFFER = new Uint8Array(BLOCK_SIZE * 2);
-  gzipAsync = promisify(gzip);
   exports_external = {};
   __export2(exports_external, {
     xor: () => xor,
@@ -14374,6 +14905,20 @@ var init_dist = __esm(() => {
       this.name = "ResourceXError";
     }
   };
+  LocatorError = class LocatorError extends ResourceXError {
+    locator;
+    constructor(message, locator) {
+      super(message);
+      this.locator = locator;
+      this.name = "LocatorError";
+    }
+  };
+  DefinitionError = class DefinitionError extends ResourceXError {
+    constructor(message) {
+      super(message);
+      this.name = "DefinitionError";
+    }
+  };
   RXDSchema = exports_external.object({
     name: exports_external.string().min(1).max(128),
     type: exports_external.string().min(1).max(64),
@@ -14386,7 +14931,7 @@ var init_dist = __esm(() => {
     keywords: exports_external.array(exports_external.string().max(64)).max(20).optional(),
     repository: exports_external.string().max(256).optional()
   }).strict();
-  gunzipAsync = promisify2(gunzip);
+  DANGEROUS_PATTERNS = /[;|&$`\n\0\r]/;
   RegistryError = class RegistryError extends ResourceXError {
     constructor(message, options) {
       super(message, options);
@@ -14531,19 +15076,69 @@ var prototype_type_default = {
 // ../../packages/node-provider/dist/index.js
 var exports_dist = {};
 __export(exports_dist, {
+  bundleResourceType: () => bundleResourceType,
+  NpmSourceLoader: () => NpmSourceLoader,
   NodeProvider: () => NodeProvider,
+  LinkedRegistry: () => LinkedRegistry,
+  FolderSourceLoader: () => FolderSourceLoader,
+  FolderLoader: () => FolderLoader,
   FileSystemRXMStore: () => FileSystemRXMStore,
   FileSystemRXAStore: () => FileSystemRXAStore
 });
-import { createHash as createHash2 } from "crypto";
+import { readFile } from "fs/promises";
+import { isAbsolute, resolve } from "path";
+import { createHash } from "crypto";
 import { createReadStream } from "fs";
 import { mkdir, readdir, stat, unlink, writeFile } from "fs/promises";
 import { join } from "path";
-import { mkdir as mkdir2, readdir as readdir22, readFile, rm, stat as stat22, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
-import { join as join22 } from "path";
+import { mkdir as mkdir2, readdir as readdir2, readFile as readFile2, rm, stat as stat2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { readdir as readdir3, readFile as readFile3, stat as stat3 } from "fs/promises";
+import { join as join3, relative } from "path";
+import { readdir as readdir4, readFile as readFile4, stat as stat4 } from "fs/promises";
+import { join as join4, relative as relative2 } from "path";
+import { lstat, mkdir as mkdir3, readdir as readdir5, readlink, rm as rm2, symlink } from "fs/promises";
+import { join as join5, resolve as resolvePath } from "path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { dirname as dirname2, join as join32 } from "path";
+import { dirname as dirname2, join as join7 } from "path";
+import { dirname, join as join6 } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+async function bundleResourceType(sourcePath, basePath) {
+  const fullPath = isAbsolute(sourcePath) ? sourcePath : resolve(basePath ?? process.cwd(), sourcePath);
+  const source = await readFile(fullPath, "utf-8");
+  const result = await Bun.build({
+    stdin: {
+      contents: source,
+      resolveDir: resolve(fullPath, ".."),
+      loader: "ts"
+    },
+    target: "bun",
+    format: "esm",
+    minify: false
+  });
+  if (!result.success) {
+    const errors = result.logs.map((log) => log.message).join(`
+`);
+    throw new Error(`Failed to bundle ${sourcePath}: ${errors}`);
+  }
+  const bundledCode = await result.outputs[0].text();
+  const tempModule = await import(fullPath);
+  const typeSource = tempModule.default;
+  if (!typeSource.name) {
+    throw new Error(`Resource type at ${sourcePath} must have a name`);
+  }
+  if (typeof typeSource.resolve !== "function") {
+    throw new Error(`Resource type at ${sourcePath} must have a resolve function`);
+  }
+  return {
+    name: typeSource.name,
+    aliases: typeSource.aliases,
+    description: typeSource.description ?? "",
+    schema: typeSource.schema,
+    code: bundledCode
+  };
+}
 
 class FileSystemRXAStore {
   basePath;
@@ -14560,16 +15155,16 @@ class FileSystemRXAStore {
     }
     const path = this.getPath(digest);
     const chunks = [];
-    const hash2 = createHash2("sha256");
+    const hash2 = createHash("sha256");
     const readStream = createReadStream(path);
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       readStream.on("data", (chunk) => {
         if (typeof chunk === "string")
           chunk = Buffer.from(chunk);
         chunks.push(chunk);
         hash2.update(chunk);
       });
-      readStream.on("end", resolve);
+      readStream.on("end", resolve2);
       readStream.on("error", () => reject(new RegistryError(`Blob not found: ${digest}`)));
     });
     const actualDigest = `sha256:${hash2.digest("hex")}`;
@@ -14579,7 +15174,7 @@ class FileSystemRXAStore {
     return Buffer.concat(chunks);
   }
   async put(data) {
-    const digest = computeDigest(data);
+    const digest = await computeDigest(data);
     const path = this.getPath(digest);
     if (await this.has(digest)) {
       return digest;
@@ -14631,30 +15226,30 @@ class FileSystemRXMStore {
   }
   getDir(name, registry2) {
     const registryDir = registry2 ?? LOCAL_DIR;
-    return join22(this.basePath, registryDir, name);
+    return join2(this.basePath, registryDir, name);
   }
   getPath(name, tag, registry2) {
-    return join22(this.getDir(name, registry2), `${tag}.json`);
+    return join2(this.getDir(name, registry2), `${tag}.json`);
   }
   async get(name, tag, registry2) {
     const path = this.getPath(name, tag, registry2);
     try {
-      const data = await readFile(path, "utf-8");
+      const data = await readFile2(path, "utf-8");
       return JSON.parse(data);
     } catch {
       return null;
     }
   }
-  async put(manifest) {
-    const path = this.getPath(manifest.name, manifest.tag, manifest.registry);
-    const dir = join22(path, "..");
+  async put(manifest2) {
+    const path = this.getPath(manifest2.name, manifest2.tag, manifest2.registry);
+    const dir = join2(path, "..");
     await mkdir2(dir, { recursive: true });
-    await writeFile2(path, JSON.stringify(manifest, null, 2), "utf-8");
+    await writeFile2(path, JSON.stringify(manifest2, null, 2), "utf-8");
   }
   async has(name, tag, registry2) {
     const path = this.getPath(name, tag, registry2);
     try {
-      await stat22(path);
+      await stat2(path);
       return true;
     } catch {
       return false;
@@ -14670,7 +15265,7 @@ class FileSystemRXMStore {
     const dir = this.getDir(name, registry2);
     const tags = [];
     try {
-      const files = await readdir22(dir);
+      const files = await readdir2(dir);
       for (const file2 of files) {
         if (file2.endsWith(".json")) {
           tags.push(file2.replace(".json", ""));
@@ -14682,26 +15277,26 @@ class FileSystemRXMStore {
   async setLatest(name, tag, registry2) {
     const dir = this.getDir(name, registry2);
     await mkdir2(dir, { recursive: true });
-    await writeFile2(join22(dir, LATEST_FILE), tag, "utf-8");
+    await writeFile2(join2(dir, LATEST_FILE), tag, "utf-8");
   }
   async getLatest(name, registry2) {
     const dir = this.getDir(name, registry2);
     try {
-      return (await readFile(join22(dir, LATEST_FILE), "utf-8")).trim();
+      return (await readFile2(join2(dir, LATEST_FILE), "utf-8")).trim();
     } catch {
       return null;
     }
   }
   async listNames(registry2, query) {
     const registryDir = registry2 ?? LOCAL_DIR;
-    const basePath = join22(this.basePath, registryDir);
+    const basePath = join2(this.basePath, registryDir);
     const names = [];
     try {
-      const entries = await readdir22(basePath);
+      const entries = await readdir2(basePath);
       for (const entry of entries) {
-        const entryPath = join22(basePath, entry);
+        const entryPath = join2(basePath, entry);
         try {
-          const entryStat = await stat22(entryPath);
+          const entryStat = await stat2(entryPath);
           if (entryStat.isDirectory()) {
             if (!query || entry.toLowerCase().includes(query.toLowerCase())) {
               names.push(entry);
@@ -14722,28 +15317,28 @@ class FileSystemRXMStore {
       registryDirs = [registry2];
     } else {
       try {
-        registryDirs = await readdir22(this.basePath);
+        registryDirs = await readdir2(this.basePath);
       } catch {
         return [];
       }
     }
     for (const regDir of registryDirs) {
-      const regPath = join22(this.basePath, regDir);
+      const regPath = join2(this.basePath, regDir);
       try {
-        const names = await readdir22(regPath);
+        const names = await readdir2(regPath);
         for (const name of names) {
           if (query && !name.toLowerCase().includes(query.toLowerCase())) {
             continue;
           }
-          const namePath = join22(regPath, name);
+          const namePath = join2(regPath, name);
           try {
-            const files = await readdir22(namePath);
+            const files = await readdir2(namePath);
             for (const file2 of files) {
               if (file2.endsWith(".json")) {
-                const filePath = join22(namePath, file2);
-                const data = await readFile(filePath, "utf-8");
-                const manifest = JSON.parse(data);
-                results.push(manifest);
+                const filePath = join2(namePath, file2);
+                const data = await readFile2(filePath, "utf-8");
+                const manifest2 = JSON.parse(data);
+                results.push(manifest2);
               }
             }
           } catch {}
@@ -14757,24 +15352,273 @@ class FileSystemRXMStore {
     return paginated;
   }
   async deleteByRegistry(registry2) {
-    const regPath = join22(this.basePath, registry2);
+    const regPath = join2(this.basePath, registry2);
     try {
       await rm(regPath, { recursive: true });
     } catch {}
   }
 }
 
+class FolderLoader {
+  async canLoad(source) {
+    try {
+      const stats = await stat3(source);
+      if (!stats.isDirectory()) {
+        return false;
+      }
+      const manifestPath = join3(source, "resource.json");
+      const manifestStats = await stat3(manifestPath);
+      return manifestStats.isFile();
+    } catch {
+      return false;
+    }
+  }
+  async load(folderPath) {
+    const resourceJsonPath = join3(folderPath, "resource.json");
+    let resourceJson;
+    try {
+      resourceJson = await readFile3(resourceJsonPath, "utf-8");
+    } catch (error48) {
+      throw new ResourceXError(`Failed to read resource.json: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    }
+    let json2;
+    try {
+      json2 = JSON.parse(resourceJson);
+    } catch (error48) {
+      throw new ResourceXError(`Invalid JSON in resource.json: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    }
+    const rxd = define(json2);
+    const files = await this.readFolderFiles(folderPath);
+    if (Object.keys(files).length === 0) {
+      throw new ResourceXError("No content files found in resource folder");
+    }
+    const rxm = manifest(rxd);
+    const rxa = await archive(files);
+    return resource(rxm, rxa);
+  }
+  async readFolderFiles(folderPath, basePath = folderPath) {
+    const files = {};
+    const entries = await readdir3(folderPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join3(folderPath, entry.name);
+      const relativePath = relative(basePath, fullPath);
+      if (relativePath === "resource.json") {
+        continue;
+      }
+      if (entry.isFile()) {
+        files[relativePath] = await readFile3(fullPath);
+      } else if (entry.isDirectory()) {
+        const subFiles = await this.readFolderFiles(fullPath, basePath);
+        Object.assign(files, subFiles);
+      }
+    }
+    return files;
+  }
+}
+
+class FolderSourceLoader {
+  async canLoad(source) {
+    try {
+      const stats = await stat4(source);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  async load(source) {
+    const canLoad = await this.canLoad(source);
+    if (!canLoad) {
+      throw new ResourceXError(`Source is not a directory: ${source}`);
+    }
+    const files = await this.readFolderFiles(source);
+    return { source, files };
+  }
+  async readFolderFiles(folderPath, basePath = folderPath) {
+    const files = {};
+    const entries = await readdir4(folderPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join4(folderPath, entry.name);
+      const relativePath = relative2(basePath, fullPath);
+      if (entry.isFile()) {
+        files[relativePath] = await readFile4(fullPath);
+      } else if (entry.isDirectory()) {
+        const subFiles = await this.readFolderFiles(fullPath, basePath);
+        Object.assign(files, subFiles);
+      }
+    }
+    return files;
+  }
+}
+
+class LinkedRegistry {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  buildLinkPath(rxi) {
+    const registry2 = rxi.registry ?? "localhost";
+    const tag = rxi.tag ?? "latest";
+    let linkPath = join5(this.basePath, registry2);
+    if (rxi.path) {
+      linkPath = join5(linkPath, rxi.path);
+    }
+    return join5(linkPath, rxi.name, tag);
+  }
+  async isSymlink(path) {
+    try {
+      const stats = await lstat(path);
+      return stats.isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }
+  async get(rxi) {
+    const linkPath = this.buildLinkPath(rxi);
+    if (!await this.isSymlink(linkPath)) {
+      throw new RegistryError(`Linked resource not found: ${format(rxi)}`);
+    }
+    const targetPath = await readlink(linkPath);
+    return loadResource(targetPath, { loader: folderLoader });
+  }
+  async put(_rxr) {
+    throw new RegistryError("LinkedRegistry does not support put(). Use link() instead.");
+  }
+  async has(rxi) {
+    const linkPath = this.buildLinkPath(rxi);
+    return this.isSymlink(linkPath);
+  }
+  async remove(rxi) {
+    const linkPath = this.buildLinkPath(rxi);
+    if (await this.isSymlink(linkPath)) {
+      await rm2(linkPath);
+    }
+  }
+  async list(options) {
+    const { query, limit, offset = 0 } = options ?? {};
+    const identifiers = [];
+    try {
+      await this.scanSymlinks(this.basePath, "", identifiers);
+    } catch {
+      return [];
+    }
+    let filtered = identifiers;
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      filtered = identifiers.filter((rxi) => {
+        const searchText = `${rxi.registry ?? ""} ${rxi.path ?? ""} ${rxi.name}`.toLowerCase();
+        return searchText.includes(lowerQuery);
+      });
+    }
+    let result = filtered.slice(offset);
+    if (limit !== undefined) {
+      result = result.slice(0, limit);
+    }
+    return result;
+  }
+  async link(devPath) {
+    const rxr = await loadResource(devPath, { loader: folderLoader });
+    const linkPath = this.buildLinkPath(rxr.identifier);
+    try {
+      const stats = await lstat(linkPath);
+      if (stats.isSymbolicLink() || stats.isDirectory()) {
+        await rm2(linkPath, { recursive: true });
+      }
+    } catch {}
+    const parentPath = join5(linkPath, "..");
+    await mkdir3(parentPath, { recursive: true });
+    const absolutePath = resolvePath(devPath);
+    await symlink(absolutePath, linkPath);
+    return rxr.identifier;
+  }
+  async unlink(rxi) {
+    return this.remove(rxi);
+  }
+  async scanSymlinks(dirPath, relativePath, identifiers) {
+    let entries;
+    try {
+      entries = await readdir5(dirPath);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join5(dirPath, entry);
+      const relPath = relativePath ? `${relativePath}/${entry}` : entry;
+      try {
+        const stats = await lstat(fullPath);
+        if (stats.isSymbolicLink()) {
+          const rxi = this.parsePathToRXI(relPath);
+          if (rxi) {
+            identifiers.push(rxi);
+          }
+        } else if (stats.isDirectory()) {
+          await this.scanSymlinks(fullPath, relPath, identifiers);
+        }
+      } catch {}
+    }
+  }
+  parsePathToRXI(relPath) {
+    const parts = relPath.split("/");
+    if (parts.length < 3) {
+      return null;
+    }
+    const tag = parts.pop();
+    const name = parts.pop();
+    const registry2 = parts.shift();
+    const path = parts.length > 0 ? parts.join("/") : undefined;
+    let locatorStr = registry2;
+    if (path)
+      locatorStr += `/${path}`;
+    locatorStr += `/${name}`;
+    if (tag !== "latest")
+      locatorStr += `:${tag}`;
+    try {
+      return parse5(locatorStr);
+    } catch {
+      return null;
+    }
+  }
+}
+
+class NpmSourceLoader {
+  folder = new FolderSourceLoader;
+  canLoad(source) {
+    return source.startsWith(NPM_PREFIX);
+  }
+  async load(source) {
+    if (!this.canLoad(source)) {
+      throw new ResourceXError(`Not an npm source: ${source}`);
+    }
+    const packageName = source.slice(NPM_PREFIX.length);
+    if (!packageName) {
+      throw new ResourceXError(`Empty package name in npm source: ${source}`);
+    }
+    const packageDir = this.resolvePackageDir(packageName);
+    const rxs = await this.folder.load(packageDir);
+    return { source, files: rxs.files };
+  }
+  resolvePackageDir(packageName) {
+    const entry = globalThis.Bun?.main ?? process.argv[1] ?? join6(process.cwd(), "noop.js");
+    const parent = pathToFileURL(entry).href;
+    try {
+      const url2 = import.meta.resolve(`${packageName}/package.json`, parent);
+      return dirname(fileURLToPath(url2));
+    } catch {
+      throw new ResourceXError(`Cannot resolve npm package: ${packageName}`);
+    }
+  }
+}
+
 class NodeProvider {
   platform = "node";
   createStores(config2) {
     const basePath = config2.path ?? DEFAULT_BASE_PATH;
     return {
-      rxaStore: new FileSystemRXAStore(join32(basePath, "blobs")),
-      rxmStore: new FileSystemRXMStore(join32(basePath, "manifests"))
+      rxaStore: new FileSystemRXAStore(join7(basePath, "blobs")),
+      rxmStore: new FileSystemRXMStore(join7(basePath, "manifests"))
     };
   }
-  createSourceLoader(_config) {
-    return new FolderSourceLoader;
+  createSourceLoaders(_config) {
+    return [new FolderSourceLoader, new NpmSourceLoader];
   }
   getDefaults(config2) {
     const envRegistry = process.env.RESOURCEX_REGISTRY;
@@ -14782,7 +15626,7 @@ class NodeProvider {
       return { registry: envRegistry };
     }
     const basePath = config2.path ?? DEFAULT_BASE_PATH;
-    const configPath = join32(basePath, "config.json");
+    const configPath = join7(basePath, "config.json");
     try {
       if (existsSync(configPath)) {
         const raw = JSON.parse(readFileSync(configPath, "utf-8"));
@@ -14799,7 +15643,7 @@ class NodeProvider {
   }
   configPath(config2) {
     const basePath = config2.path ?? DEFAULT_BASE_PATH;
-    return join32(basePath, "config.json");
+    return join7(basePath, "config.json");
   }
   readConfig(config2) {
     const configPath = this.configPath(config2);
@@ -14862,10 +15706,14 @@ class NodeProvider {
     this.writeConfig(config2, data);
   }
 }
-var LOCAL_DIR = "_local", LATEST_FILE = ".latest", DEFAULT_BASE_PATH;
+var LOCAL_DIR = "_local", LATEST_FILE = ".latest", folderLoader, NPM_PREFIX = "npm:", DEFAULT_BASE_PATH;
 var init_dist2 = __esm(() => {
   init_dist();
   init_dist();
+  init_dist();
+  init_dist();
+  init_dist();
+  folderLoader = new FolderLoader;
   DEFAULT_BASE_PATH = `${homedir()}/.deepractice/resourcex`;
 });
 
@@ -14881,7 +15729,7 @@ import { createServer as createServerHTTP } from "http";
 import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
-import crypto from "crypto";
+import crypto2 from "crypto";
 async function readWithoutBlocking(readPromise) {
   return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(undefined))]);
 }
@@ -15117,7 +15965,7 @@ var RequestError, toRequestError = (e2) => {
         });
         if (!chunk) {
           if (i2 === 1) {
-            await new Promise((resolve) => setTimeout(resolve));
+            await new Promise((resolve2) => setTimeout(resolve2));
             maxReadCount = 3;
             continue;
           }
@@ -15392,7 +16240,7 @@ var init_dist3 = __esm(() => {
   Object.setPrototypeOf(Response2, GlobalResponse);
   Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
   if (typeof global.crypto === "undefined") {
-    global.crypto = crypto;
+    global.crypto = crypto2;
   }
   outgoingEnded = Symbol("outgoingEnded");
 });
@@ -16802,14 +17650,14 @@ import { createResourceX, setProvider } from "resourcexjs";
 
 // src/lib/paths.ts
 import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
-var RX_HOME = process.env.RESOURCEX_HOME || process.env.RX_HOME || join4(homedir2(), ".deepractice", "resourcex");
+import { join as join8 } from "path";
+var RX_HOME = process.env.RESOURCEX_HOME || process.env.RX_HOME || join8(homedir2(), ".deepractice", "resourcex");
 var PATHS = {
   root: RX_HOME,
-  config: join4(RX_HOME, "config.json"),
-  local: join4(RX_HOME, "local"),
-  cache: join4(RX_HOME, "cache"),
-  linked: join4(RX_HOME, "linked")
+  config: join8(RX_HOME, "config.json"),
+  local: join8(RX_HOME, "local"),
+  cache: join8(RX_HOME, "cache"),
+  linked: join8(RX_HOME, "linked")
 };
 
 // src/lib/config.ts
@@ -16939,13 +17787,13 @@ var add = defineCommand({
   async run({ args }) {
     try {
       const rx = await getClient();
-      const resource = await rx.add(args.path);
+      const resource2 = await rx.add(args.path);
       consola.success(`Added resource:
 `);
-      console.log(`  Locator:  ${resource.locator}`);
-      console.log(`  Name:     ${resource.definition.name}`);
-      console.log(`  Type:     ${resource.definition.type}`);
-      console.log(`  Tag:      ${resource.definition.tag}`);
+      console.log(`  Locator:  ${resource2.locator}`);
+      console.log(`  Name:     ${resource2.definition.name}`);
+      console.log(`  Type:     ${resource2.definition.type}`);
+      console.log(`  Tag:      ${resource2.definition.tag}`);
     } catch (error48) {
       consola.error(error48 instanceof Error ? error48.message : "Failed to add resource");
       process.exit(1);
@@ -17059,13 +17907,13 @@ var info = defineCommand({
   async run({ args }) {
     try {
       const rx = await getClient();
-      const resource = await rx.info(args.locator);
-      const { definition, source } = resource;
+      const resource2 = await rx.info(args.locator);
+      const { definition, source } = resource2;
       console.log();
       console.log(`  ${definition.name}:${definition.tag}`);
       console.log(`  ${"\u2500".repeat(40)}`);
       console.log();
-      console.log(`  Locator:  ${resource.locator}`);
+      console.log(`  Locator:  ${resource2.locator}`);
       if (definition.registry) {
         console.log(`  Registry: ${definition.registry}`);
       }
@@ -17436,7 +18284,7 @@ var search = defineCommand({
 });
 
 // src/commands/server.ts
-import { join as join6 } from "path";
+import { join as join10 } from "path";
 var server = defineCommand({
   meta: {
     name: "server",
@@ -17460,8 +18308,8 @@ var server = defineCommand({
     const { FileSystemRXAStore: FileSystemRXAStore2, FileSystemRXMStore: FileSystemRXMStore2 } = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const { serve: serve2 } = await Promise.resolve().then(() => (init_dist3(), exports_dist2));
     const app = createRegistryServer({
-      rxaStore: new FileSystemRXAStore2(join6(storagePath, "blobs")),
-      rxmStore: new FileSystemRXMStore2(join6(storagePath, "manifests"))
+      rxaStore: new FileSystemRXAStore2(join10(storagePath, "blobs")),
+      rxmStore: new FileSystemRXMStore2(join10(storagePath, "manifests"))
     });
     consola.info(`Starting registry server...`);
     console.log();
@@ -17538,4 +18386,4 @@ var main = defineCommand({
 });
 runMain(main);
 
-//# debugId=D37BF1EEFFFDA7D564756E2164756E21
+//# debugId=F1DFD9AFB5D18EC864756E2164756E21