@resourcexjs/cli 2.6.0 → 2.8.0

package/dist/index.js

@@ -770,249 +770,614 @@ var init_prompt = __esm(() => {
 });
 
 // ../../packages/core/dist/index.js
-import { gzip } from "zlib";
 import { promisify } from "util";
-import { gunzip } from "zlib";
+import { gzip } from "zlib";
 import { promisify as promisify2 } from "util";
+import { gunzip } from "zlib";
+import { readdir, readFile, stat } from "fs/promises";
 import { join, relative } from "path";
-import { stat, readFile as readFile2, readdir } from "fs/promises";
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
+import { join as join2, relative as relative2 } from "path";
 import { createHash } from "crypto";
-function $constructor(name, initializer, params) {
-  function init2(inst, def) {
-    if (!inst._zod) {
-      Object.defineProperty(inst, "_zod", {
-        value: {
-          def,
-          constr: _3,
-          traits: new Set
-        },
-        enumerable: false
-      });
-    }
-    if (inst._zod.traits.has(name)) {
-      return;
-    }
-    inst._zod.traits.add(name);
-    initializer(inst, def);
-    const proto = _3.prototype;
-    const keys = Object.keys(proto);
-    for (let i2 = 0;i2 < keys.length; i2++) {
-      const k2 = keys[i2];
-      if (!(k2 in inst)) {
-        inst[k2] = proto[k2].bind(inst);
-      }
-    }
-  }
-  const Parent = params?.Parent ?? Object;
-
-  class Definition extends Parent {
-  }
-  Object.defineProperty(Definition, "name", { value: name });
-  function _3(def) {
-    var _a;
-    const inst = params?.Parent ? new Definition : this;
-    init2(inst, def);
-    (_a = inst._zod).deferred ?? (_a.deferred = []);
-    for (const fn of inst._zod.deferred) {
-      fn();
-    }
-    return inst;
-  }
-  Object.defineProperty(_3, "init", { value: init2 });
-  Object.defineProperty(_3, Symbol.hasInstance, {
-    value: (inst) => {
-      if (params?.Parent && inst instanceof params.Parent)
-        return true;
-      return inst?._zod?.traits?.has(name);
-    }
-  });
-  Object.defineProperty(_3, "name", { value: name });
-  return _3;
-}
-function config(newConfig) {
-  if (newConfig)
-    Object.assign(globalConfig, newConfig);
-  return globalConfig;
-}
-function assertEqual(val) {
-  return val;
-}
-function assertNotEqual(val) {
-  return val;
-}
-function assertIs(_arg) {}
-function assertNever(_x) {
-  throw new Error("Unexpected value in exhaustive check");
+function writeString(view, offset, size, value) {
+  if (value)
+    encoder.encodeInto(value, view.subarray(offset, offset + size));
 }
-function assert(_3) {}
-function getEnumValues(entries) {
-  const numericValues = Object.values(entries).filter((v2) => typeof v2 === "number");
-  const values = Object.entries(entries).filter(([k2, _3]) => numericValues.indexOf(+k2) === -1).map(([_3, v2]) => v2);
-  return values;
+function writeOctal(view, offset, size, value) {
+  if (value === undefined)
+    return;
+  const octalString = value.toString(8).padStart(size - 1, "0");
+  encoder.encodeInto(octalString, view.subarray(offset, offset + size - 1));
 }
-function joinValues(array, separator = "|") {
-  return array.map((val) => stringifyPrimitive(val)).join(separator);
+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 jsonStringifyReplacer(_3, value) {
-  if (typeof value === "bigint")
-    return value.toString();
-  return value;
+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 cached(getter) {
-  const set = false;
+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 {
-    get value() {
-      if (!set) {
-        const value = getter();
-        Object.defineProperty(this, "value", { value });
-        return value;
-      }
-      throw new Error("cached value already set");
-    }
+    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 nullish(input) {
-  return input === null || input === undefined;
-}
-function cleanRegex(source) {
-  const start = source.startsWith("^") ? 1 : 0;
-  const end = source.endsWith("$") ? source.length - 1 : source.length;
-  return source.slice(start, end);
+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 floatSafeRemainder(val, step) {
-  const valDecCount = (val.toString().split(".")[1] || "").length;
-  const stepString = step.toString();
-  let stepDecCount = (stepString.split(".")[1] || "").length;
-  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
-    const match = stepString.match(/\d?e-(\d?)/);
-    if (match?.[1]) {
-      stepDecCount = Number.parseInt(match[1]);
+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;
     }
   }
-  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
-  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
-  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
-  return valInt % stepInt / 10 ** decCount;
+  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 defineLazy(object, key, getter) {
-  let value = undefined;
-  Object.defineProperty(object, key, {
-    get() {
-      if (value === EVALUATING) {
-        return;
+function getHeaderBlocks(header) {
+  const base = createTarHeader(header);
+  const pax = generatePax(header);
+  if (!pax)
+    return [base];
+  const paxPadding = -pax.paxBody.length & BLOCK_SIZE_MASK;
+  const paddingBlocks = paxPadding > 0 ? [ZERO_BLOCK.subarray(0, paxPadding)] : [];
+  return [
+    pax.paxHeader,
+    pax.paxBody,
+    ...paddingBlocks,
+    base
+  ];
+}
+function createTarPacker(onData, onError, onFinalize) {
+  let currentHeader = null;
+  let bytesWritten = 0;
+  let finalized = false;
+  return {
+    add(header) {
+      if (finalized) {
+        const error = /* @__PURE__ */ new Error("No new tar entries after finalize.");
+        onError(error);
+        throw error;
       }
-      if (value === undefined) {
-        value = EVALUATING;
-        value = getter();
+      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);
       }
-      return value;
-    },
-    set(v2) {
-      Object.defineProperty(object, key, {
-        value: v2
-      });
     },
-    configurable: true
-  });
-}
-function objectClone(obj) {
-  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+    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 assignProp(target, prop, value) {
-  Object.defineProperty(target, prop, {
-    value,
-    writable: true,
-    enumerable: true,
-    configurable: true
-  });
+function createTarPacker2() {
+  let streamController;
+  let packer;
+  return {
+    readable: new ReadableStream({ start(controller) {
+      streamController = controller;
+      packer = createTarPacker(controller.enqueue.bind(controller), controller.error.bind(controller), controller.close.bind(controller));
+    } }),
+    controller: {
+      add(header) {
+        const bodyless = isBodyless(header);
+        const 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);
+      }
+    }
+  };
 }
-function mergeDefs(...defs) {
-  const mergedDescriptors = {};
-  for (const def of defs) {
-    const descriptors = Object.getOwnPropertyDescriptors(def);
-    Object.assign(mergedDescriptors, descriptors);
+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();
   }
-  return Object.defineProperties({}, mergedDescriptors);
-}
-function cloneDef(schema) {
-  return mergeDefs(schema._zod.def);
-}
-function getElementAtPath(obj, path) {
-  if (!path)
-    return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
 }
-function promiseAllObject(promisesObj) {
-  const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises).then((results) => {
-    const resolvedObj = {};
-    for (let i2 = 0;i2 < keys.length; i2++) {
-      resolvedObj[keys[i2]] = results[i2];
+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}".`);
+        }
     }
-    return resolvedObj;
-  });
+  })().then(() => controller.finalize()).catch((err) => controller.error(err));
+  return new Uint8Array(await streamToBuffer(readable));
 }
-function randomString(length = 10) {
-  const chars = "abcdefghijklmnopqrstuvwxyz";
-  let str = "";
-  for (let i2 = 0;i2 < length; i2++) {
-    str += chars[Math.floor(Math.random() * chars.length)];
+
+class RXAImpl {
+  _buffer;
+  constructor(buffer) {
+    this._buffer = buffer;
   }
-  return str;
-}
-function esc(str) {
-  return JSON.stringify(str);
-}
-function slugify(input) {
-  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function isObject(data) {
-  return typeof data === "object" && data !== null && !Array.isArray(data);
-}
-function isPlainObject2(o3) {
-  if (isObject(o3) === false)
-    return false;
-  const ctor = o3.constructor;
-  if (ctor === undefined)
-    return true;
-  if (typeof ctor !== "function")
-    return true;
-  const prot = ctor.prototype;
-  if (isObject(prot) === false)
-    return false;
-  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
-    return false;
+  get stream() {
+    const buffer = this._buffer;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(buffer));
+        controller.close();
+      }
+    });
   }
-  return true;
-}
-function shallowClone(o3) {
-  if (isPlainObject2(o3))
-    return { ...o3 };
-  if (Array.isArray(o3))
-    return [...o3];
-  return o3;
-}
-function numKeys(data) {
-  let keyCount = 0;
-  for (const key in data) {
-    if (Object.prototype.hasOwnProperty.call(data, key)) {
-      keyCount++;
-    }
+  async buffer() {
+    return this._buffer;
   }
-  return keyCount;
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function clone(inst, def, params) {
-  const cl = new inst._zod.constr(def ?? inst._zod.def);
-  if (!def || params?.parent)
-    cl._zod.parent = inst;
-  return cl;
-}
-function normalizeParams(_params) {
-  const params = _params;
+async function archive(files) {
+  const entries = Object.entries(files).map(([name, content]) => {
+    return {
+      header: { name, size: content.length, type: "file" },
+      body: new Uint8Array(content)
+    };
+  });
+  const tarBuffer = await packTar(entries);
+  const gzipBuffer = await gzipAsync(Buffer.from(tarBuffer));
+  return new RXAImpl(gzipBuffer);
+}
+function $constructor(name, initializer, params) {
+  function init2(inst, def) {
+    if (!inst._zod) {
+      Object.defineProperty(inst, "_zod", {
+        value: {
+          def,
+          constr: _3,
+          traits: new Set
+        },
+        enumerable: false
+      });
+    }
+    if (inst._zod.traits.has(name)) {
+      return;
+    }
+    inst._zod.traits.add(name);
+    initializer(inst, def);
+    const proto = _3.prototype;
+    const keys = Object.keys(proto);
+    for (let i2 = 0;i2 < keys.length; i2++) {
+      const k2 = keys[i2];
+      if (!(k2 in inst)) {
+        inst[k2] = proto[k2].bind(inst);
+      }
+    }
+  }
+  const Parent = params?.Parent ?? Object;
+
+  class Definition extends Parent {
+  }
+  Object.defineProperty(Definition, "name", { value: name });
+  function _3(def) {
+    var _a;
+    const inst = params?.Parent ? new Definition : this;
+    init2(inst, def);
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    for (const fn of inst._zod.deferred) {
+      fn();
+    }
+    return inst;
+  }
+  Object.defineProperty(_3, "init", { value: init2 });
+  Object.defineProperty(_3, Symbol.hasInstance, {
+    value: (inst) => {
+      if (params?.Parent && inst instanceof params.Parent)
+        return true;
+      return inst?._zod?.traits?.has(name);
+    }
+  });
+  Object.defineProperty(_3, "name", { value: name });
+  return _3;
+}
+function config(newConfig) {
+  if (newConfig)
+    Object.assign(globalConfig, newConfig);
+  return globalConfig;
+}
+function assertEqual(val) {
+  return val;
+}
+function assertNotEqual(val) {
+  return val;
+}
+function assertIs(_arg) {}
+function assertNever(_x) {
+  throw new Error("Unexpected value in exhaustive check");
+}
+function assert(_3) {}
+function getEnumValues(entries) {
+  const numericValues = Object.values(entries).filter((v2) => typeof v2 === "number");
+  const values = Object.entries(entries).filter(([k2, _3]) => numericValues.indexOf(+k2) === -1).map(([_3, v2]) => v2);
+  return values;
+}
+function joinValues(array, separator = "|") {
+  return array.map((val) => stringifyPrimitive(val)).join(separator);
+}
+function jsonStringifyReplacer(_3, value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  return value;
+}
+function cached(getter) {
+  const set = false;
+  return {
+    get value() {
+      if (!set) {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+      throw new Error("cached value already set");
+    }
+  };
+}
+function nullish(input) {
+  return input === null || input === undefined;
+}
+function cleanRegex(source) {
+  const start = source.startsWith("^") ? 1 : 0;
+  const end = source.endsWith("$") ? source.length - 1 : source.length;
+  return source.slice(start, end);
+}
+function floatSafeRemainder(val, step) {
+  const valDecCount = (val.toString().split(".")[1] || "").length;
+  const stepString = step.toString();
+  let stepDecCount = (stepString.split(".")[1] || "").length;
+  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
+    const match = stepString.match(/\d?e-(\d?)/);
+    if (match?.[1]) {
+      stepDecCount = Number.parseInt(match[1]);
+    }
+  }
+  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
+  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+  return valInt % stepInt / 10 ** decCount;
+}
+function defineLazy(object, key, getter) {
+  let value = undefined;
+  Object.defineProperty(object, key, {
+    get() {
+      if (value === EVALUATING) {
+        return;
+      }
+      if (value === undefined) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
+    },
+    set(v2) {
+      Object.defineProperty(object, key, {
+        value: v2
+      });
+    },
+    configurable: true
+  });
+}
+function objectClone(obj) {
+  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
+function assignProp(target, prop, value) {
+  Object.defineProperty(target, prop, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function mergeDefs(...defs) {
+  const mergedDescriptors = {};
+  for (const def of defs) {
+    const descriptors = Object.getOwnPropertyDescriptors(def);
+    Object.assign(mergedDescriptors, descriptors);
+  }
+  return Object.defineProperties({}, mergedDescriptors);
+}
+function cloneDef(schema) {
+  return mergeDefs(schema._zod.def);
+}
+function getElementAtPath(obj, path) {
+  if (!path)
+    return obj;
+  return path.reduce((acc, key) => acc?.[key], obj);
+}
+function promiseAllObject(promisesObj) {
+  const keys = Object.keys(promisesObj);
+  const promises = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises).then((results) => {
+    const resolvedObj = {};
+    for (let i2 = 0;i2 < keys.length; i2++) {
+      resolvedObj[keys[i2]] = results[i2];
+    }
+    return resolvedObj;
+  });
+}
+function randomString(length = 10) {
+  const chars = "abcdefghijklmnopqrstuvwxyz";
+  let str = "";
+  for (let i2 = 0;i2 < length; i2++) {
+    str += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return str;
+}
+function esc(str) {
+  return JSON.stringify(str);
+}
+function slugify(input) {
+  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+function isPlainObject2(o3) {
+  if (isObject(o3) === false)
+    return false;
+  const ctor = o3.constructor;
+  if (ctor === undefined)
+    return true;
+  if (typeof ctor !== "function")
+    return true;
+  const prot = ctor.prototype;
+  if (isObject(prot) === false)
+    return false;
+  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
+    return false;
+  }
+  return true;
+}
+function shallowClone(o3) {
+  if (isPlainObject2(o3))
+    return { ...o3 };
+  if (Array.isArray(o3))
+    return [...o3];
+  return o3;
+}
+function numKeys(data) {
+  let keyCount = 0;
+  for (const key in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key)) {
+      keyCount++;
+    }
+  }
+  return keyCount;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(inst, def, params) {
+  const cl = new inst._zod.constr(def ?? inst._zod.def);
+  if (!def || params?.parent)
+    cl._zod.parent = inst;
+  return cl;
+}
+function normalizeParams(_params) {
+  const params = _params;
   if (!params)
     return {};
   if (typeof params === "string")
@@ -4224,641 +4589,269 @@ function convertBaseSchema(schema, ctx) {
         stringSchema = stringSchema.max(schema.maxLength);
       }
       if (schema.pattern) {
-        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
-      }
-      zodSchema = stringSchema;
-      break;
-    }
-    case "number":
-    case "integer": {
-      let numberSchema = type === "integer" ? z2.number().int() : z2.number();
-      if (typeof schema.minimum === "number") {
-        numberSchema = numberSchema.min(schema.minimum);
-      }
-      if (typeof schema.maximum === "number") {
-        numberSchema = numberSchema.max(schema.maximum);
-      }
-      if (typeof schema.exclusiveMinimum === "number") {
-        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
-      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
-        numberSchema = numberSchema.gt(schema.minimum);
-      }
-      if (typeof schema.exclusiveMaximum === "number") {
-        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
-      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
-        numberSchema = numberSchema.lt(schema.maximum);
-      }
-      if (typeof schema.multipleOf === "number") {
-        numberSchema = numberSchema.multipleOf(schema.multipleOf);
-      }
-      zodSchema = numberSchema;
-      break;
-    }
-    case "boolean": {
-      zodSchema = z2.boolean();
-      break;
-    }
-    case "null": {
-      zodSchema = z2.null();
-      break;
-    }
-    case "object": {
-      const shape = {};
-      const properties = schema.properties || {};
-      const requiredSet = new Set(schema.required || []);
-      for (const [key, propSchema] of Object.entries(properties)) {
-        const propZodSchema = convertSchema(propSchema, ctx);
-        shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
-      }
-      if (schema.propertyNames) {
-        const keySchema = convertSchema(schema.propertyNames, ctx);
-        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z2.any();
-        if (Object.keys(shape).length === 0) {
-          zodSchema = z2.record(keySchema, valueSchema);
-          break;
-        }
-        const objectSchema2 = z2.object(shape).passthrough();
-        const recordSchema = z2.looseRecord(keySchema, valueSchema);
-        zodSchema = z2.intersection(objectSchema2, recordSchema);
-        break;
-      }
-      if (schema.patternProperties) {
-        const patternProps = schema.patternProperties;
-        const patternKeys = Object.keys(patternProps);
-        const looseRecords = [];
-        for (const pattern of patternKeys) {
-          const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z2.string().regex(new RegExp(pattern));
-          looseRecords.push(z2.looseRecord(keySchema, patternValue));
-        }
-        const schemasToIntersect = [];
-        if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z2.object(shape).passthrough());
-        }
-        schemasToIntersect.push(...looseRecords);
-        if (schemasToIntersect.length === 0) {
-          zodSchema = z2.object({}).passthrough();
-        } else if (schemasToIntersect.length === 1) {
-          zodSchema = schemasToIntersect[0];
-        } else {
-          let result = z2.intersection(schemasToIntersect[0], schemasToIntersect[1]);
-          for (let i2 = 2;i2 < schemasToIntersect.length; i2++) {
-            result = z2.intersection(result, schemasToIntersect[i2]);
-          }
-          zodSchema = result;
-        }
-        break;
-      }
-      const objectSchema = z2.object(shape);
-      if (schema.additionalProperties === false) {
-        zodSchema = objectSchema.strict();
-      } else if (typeof schema.additionalProperties === "object") {
-        zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
-      } else {
-        zodSchema = objectSchema.passthrough();
-      }
-      break;
-    }
-    case "array": {
-      const prefixItems = schema.prefixItems;
-      const items = schema.items;
-      if (prefixItems && Array.isArray(prefixItems)) {
-        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
-        const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : undefined;
-        if (rest) {
-          zodSchema = z2.tuple(tupleItems).rest(rest);
-        } else {
-          zodSchema = z2.tuple(tupleItems);
-        }
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z2.minLength(schema.minItems));
-        }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z2.maxLength(schema.maxItems));
-        }
-      } else if (Array.isArray(items)) {
-        const tupleItems = items.map((item) => convertSchema(item, ctx));
-        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : undefined;
-        if (rest) {
-          zodSchema = z2.tuple(tupleItems).rest(rest);
-        } else {
-          zodSchema = z2.tuple(tupleItems);
-        }
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z2.minLength(schema.minItems));
-        }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z2.maxLength(schema.maxItems));
-        }
-      } else if (items !== undefined) {
-        const element = convertSchema(items, ctx);
-        let arraySchema = z2.array(element);
-        if (typeof schema.minItems === "number") {
-          arraySchema = arraySchema.min(schema.minItems);
-        }
-        if (typeof schema.maxItems === "number") {
-          arraySchema = arraySchema.max(schema.maxItems);
-        }
-        zodSchema = arraySchema;
-      } else {
-        zodSchema = z2.array(z2.any());
-      }
-      break;
-    }
-    default:
-      throw new Error(`Unsupported type: ${type}`);
-  }
-  if (schema.description) {
-    zodSchema = zodSchema.describe(schema.description);
-  }
-  if (schema.default !== undefined) {
-    zodSchema = zodSchema.default(schema.default);
-  }
-  return zodSchema;
-}
-function convertSchema(schema, ctx) {
-  if (typeof schema === "boolean") {
-    return schema ? z2.any() : z2.never();
-  }
-  let baseSchema = convertBaseSchema(schema, ctx);
-  const hasExplicitType = schema.type || schema.enum !== undefined || schema.const !== undefined;
-  if (schema.anyOf && Array.isArray(schema.anyOf)) {
-    const options = schema.anyOf.map((s2) => convertSchema(s2, ctx));
-    const anyOfUnion = z2.union(options);
-    baseSchema = hasExplicitType ? z2.intersection(baseSchema, anyOfUnion) : anyOfUnion;
-  }
-  if (schema.oneOf && Array.isArray(schema.oneOf)) {
-    const options = schema.oneOf.map((s2) => convertSchema(s2, ctx));
-    const oneOfUnion = z2.xor(options);
-    baseSchema = hasExplicitType ? z2.intersection(baseSchema, oneOfUnion) : oneOfUnion;
-  }
-  if (schema.allOf && Array.isArray(schema.allOf)) {
-    if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z2.any();
-    } else {
-      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
-      const startIdx = hasExplicitType ? 0 : 1;
-      for (let i2 = startIdx;i2 < schema.allOf.length; i2++) {
-        result = z2.intersection(result, convertSchema(schema.allOf[i2], ctx));
-      }
-      baseSchema = result;
-    }
-  }
-  if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z2.nullable(baseSchema);
-  }
-  if (schema.readOnly === true) {
-    baseSchema = z2.readonly(baseSchema);
-  }
-  const extraMeta = {};
-  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
-  for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
-    }
-  }
-  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
-  for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
-    }
-  }
-  for (const key of Object.keys(schema)) {
-    if (!RECOGNIZED_KEYS.has(key)) {
-      extraMeta[key] = schema[key];
-    }
-  }
-  if (Object.keys(extraMeta).length > 0) {
-    ctx.registry.add(baseSchema, extraMeta);
-  }
-  return baseSchema;
-}
-function fromJSONSchema(schema, params) {
-  if (typeof schema === "boolean") {
-    return schema ? z2.any() : z2.never();
-  }
-  const version2 = detectVersion(schema, params?.defaultTarget);
-  const defs = schema.$defs || schema.definitions || {};
-  const ctx = {
-    version: version2,
-    defs,
-    refs: new Map,
-    processing: new Set,
-    rootSchema: schema,
-    registry: params?.registry ?? globalRegistry
-  };
-  return convertSchema(schema, ctx);
-}
-function string3(params) {
-  return _coercedString(ZodString, params);
-}
-function number3(params) {
-  return _coercedNumber(ZodNumber, params);
-}
-function boolean3(params) {
-  return _coercedBoolean(ZodBoolean, params);
-}
-function bigint3(params) {
-  return _coercedBigint(ZodBigInt, params);
-}
-function date4(params) {
-  return _coercedDate(ZodDate, params);
-}
-function define(input) {
-  if (input === null || typeof input !== "object") {
-    throw new DefinitionError("definition must be an object");
-  }
-  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 ?? validated.version ?? 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 manifest(rxd) {
-  return {
-    registry: rxd.registry,
-    path: rxd.path,
-    name: rxd.name,
-    type: rxd.type,
-    tag: rxd.tag ?? "latest"
-  };
-}
-function writeString(view, offset, size, value) {
-  if (value)
-    encoder.encodeInto(value, view.subarray(offset, offset + size));
-}
-function writeOctal(view, offset, size, value) {
-  if (value === undefined)
-    return;
-  const octalString = value.toString(8).padStart(size - 1, "0");
-  encoder.encodeInto(octalString, view.subarray(offset, offset + size - 1));
-}
-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 record2 = `${key}=${value}
-`;
-    const partLength = encoder.encode(record2).length + 1;
-    let totalLength = partLength + String(partLength).length;
-    totalLength = partLength + String(totalLength).length;
-    return `${totalLength} ${record2}`;
-  }).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 error48 = /* @__PURE__ */ new Error("No new tar entries after finalize.");
-        onError(error48);
-        throw error48;
-      }
-      if (currentHeader !== null) {
-        const error48 = /* @__PURE__ */ new Error("Previous entry must be completed before adding a new one");
-        onError(error48);
-        throw error48;
-      }
-      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 (error48) {
-        onError(error48);
-      }
-    },
-    write(chunk) {
-      if (!currentHeader) {
-        const error48 = /* @__PURE__ */ new Error("No active tar entry.");
-        onError(error48);
-        throw error48;
+        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
       }
-      if (finalized) {
-        const error48 = /* @__PURE__ */ new Error("Cannot write data after finalize.");
-        onError(error48);
-        throw error48;
+      zodSchema = stringSchema;
+      break;
+    }
+    case "number":
+    case "integer": {
+      let numberSchema = type === "integer" ? z2.number().int() : z2.number();
+      if (typeof schema.minimum === "number") {
+        numberSchema = numberSchema.min(schema.minimum);
       }
-      const newTotal = bytesWritten + chunk.length;
-      if (newTotal > currentHeader.size) {
-        const error48 = /* @__PURE__ */ new Error(`"${currentHeader.name}" exceeds given size of ${currentHeader.size} bytes.`);
-        onError(error48);
-        throw error48;
+      if (typeof schema.maximum === "number") {
+        numberSchema = numberSchema.max(schema.maximum);
       }
-      try {
-        bytesWritten = newTotal;
-        onData(chunk);
-      } catch (error48) {
-        onError(error48);
+      if (typeof schema.exclusiveMinimum === "number") {
+        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
+      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
+        numberSchema = numberSchema.gt(schema.minimum);
       }
-    },
-    endEntry() {
-      if (!currentHeader) {
-        const error48 = /* @__PURE__ */ new Error("No active entry to end.");
-        onError(error48);
-        throw error48;
+      if (typeof schema.exclusiveMaximum === "number") {
+        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
+      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
+        numberSchema = numberSchema.lt(schema.maximum);
       }
-      if (finalized) {
-        const error48 = /* @__PURE__ */ new Error("Cannot end entry after finalize.");
-        onError(error48);
-        throw error48;
+      if (typeof schema.multipleOf === "number") {
+        numberSchema = numberSchema.multipleOf(schema.multipleOf);
       }
-      try {
-        if (bytesWritten !== currentHeader.size) {
-          const error48 = /* @__PURE__ */ new Error(`Size mismatch for "${currentHeader.name}".`);
-          onError(error48);
-          throw error48;
+      zodSchema = numberSchema;
+      break;
+    }
+    case "boolean": {
+      zodSchema = z2.boolean();
+      break;
+    }
+    case "null": {
+      zodSchema = z2.null();
+      break;
+    }
+    case "object": {
+      const shape = {};
+      const properties = schema.properties || {};
+      const requiredSet = new Set(schema.required || []);
+      for (const [key, propSchema] of Object.entries(properties)) {
+        const propZodSchema = convertSchema(propSchema, ctx);
+        shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
+      }
+      if (schema.propertyNames) {
+        const keySchema = convertSchema(schema.propertyNames, ctx);
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z2.any();
+        if (Object.keys(shape).length === 0) {
+          zodSchema = z2.record(keySchema, valueSchema);
+          break;
         }
-        const paddingSize = -currentHeader.size & BLOCK_SIZE_MASK;
-        if (paddingSize > 0)
-          onData(new Uint8Array(paddingSize));
-        currentHeader = null;
-        bytesWritten = 0;
-      } catch (error48) {
-        onError(error48);
-        throw error48;
+        const objectSchema2 = z2.object(shape).passthrough();
+        const recordSchema = z2.looseRecord(keySchema, valueSchema);
+        zodSchema = z2.intersection(objectSchema2, recordSchema);
+        break;
       }
-    },
-    finalize() {
-      if (finalized) {
-        const error48 = /* @__PURE__ */ new Error("Archive has already been finalized");
-        onError(error48);
-        throw error48;
+      if (schema.patternProperties) {
+        const patternProps = schema.patternProperties;
+        const patternKeys = Object.keys(patternProps);
+        const looseRecords = [];
+        for (const pattern of patternKeys) {
+          const patternValue = convertSchema(patternProps[pattern], ctx);
+          const keySchema = z2.string().regex(new RegExp(pattern));
+          looseRecords.push(z2.looseRecord(keySchema, patternValue));
+        }
+        const schemasToIntersect = [];
+        if (Object.keys(shape).length > 0) {
+          schemasToIntersect.push(z2.object(shape).passthrough());
+        }
+        schemasToIntersect.push(...looseRecords);
+        if (schemasToIntersect.length === 0) {
+          zodSchema = z2.object({}).passthrough();
+        } else if (schemasToIntersect.length === 1) {
+          zodSchema = schemasToIntersect[0];
+        } else {
+          let result = z2.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          for (let i2 = 2;i2 < schemasToIntersect.length; i2++) {
+            result = z2.intersection(result, schemasToIntersect[i2]);
+          }
+          zodSchema = result;
+        }
+        break;
       }
-      if (currentHeader !== null) {
-        const error48 = /* @__PURE__ */ new Error("Cannot finalize while an entry is still active");
-        onError(error48);
-        throw error48;
+      const objectSchema = z2.object(shape);
+      if (schema.additionalProperties === false) {
+        zodSchema = objectSchema.strict();
+      } else if (typeof schema.additionalProperties === "object") {
+        zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
+      } else {
+        zodSchema = objectSchema.passthrough();
       }
-      try {
-        onData(EOF_BUFFER);
-        finalized = true;
-        if (onFinalize)
-          onFinalize();
-      } catch (error48) {
-        onError(error48);
+      break;
+    }
+    case "array": {
+      const prefixItems = schema.prefixItems;
+      const items = schema.items;
+      if (prefixItems && Array.isArray(prefixItems)) {
+        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
+        const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : undefined;
+        if (rest) {
+          zodSchema = z2.tuple(tupleItems).rest(rest);
+        } else {
+          zodSchema = z2.tuple(tupleItems);
+        }
+        if (typeof schema.minItems === "number") {
+          zodSchema = zodSchema.check(z2.minLength(schema.minItems));
+        }
+        if (typeof schema.maxItems === "number") {
+          zodSchema = zodSchema.check(z2.maxLength(schema.maxItems));
+        }
+      } else if (Array.isArray(items)) {
+        const tupleItems = items.map((item) => convertSchema(item, ctx));
+        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : undefined;
+        if (rest) {
+          zodSchema = z2.tuple(tupleItems).rest(rest);
+        } else {
+          zodSchema = z2.tuple(tupleItems);
+        }
+        if (typeof schema.minItems === "number") {
+          zodSchema = zodSchema.check(z2.minLength(schema.minItems));
+        }
+        if (typeof schema.maxItems === "number") {
+          zodSchema = zodSchema.check(z2.maxLength(schema.maxItems));
+        }
+      } else if (items !== undefined) {
+        const element = convertSchema(items, ctx);
+        let arraySchema = z2.array(element);
+        if (typeof schema.minItems === "number") {
+          arraySchema = arraySchema.min(schema.minItems);
+        }
+        if (typeof schema.maxItems === "number") {
+          arraySchema = arraySchema.max(schema.maxItems);
+        }
+        zodSchema = arraySchema;
+      } else {
+        zodSchema = z2.array(z2.any());
       }
+      break;
     }
-  };
+    default:
+      throw new Error(`Unsupported type: ${type}`);
+  }
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  if (schema.default !== undefined) {
+    zodSchema = zodSchema.default(schema.default);
+  }
+  return zodSchema;
 }
-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);
+function convertSchema(schema, ctx) {
+  if (typeof schema === "boolean") {
+    return schema ? z2.any() : z2.never();
+  }
+  let baseSchema = convertBaseSchema(schema, ctx);
+  const hasExplicitType = schema.type || schema.enum !== undefined || schema.const !== undefined;
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    const options = schema.anyOf.map((s2) => convertSchema(s2, ctx));
+    const anyOfUnion = z2.union(options);
+    baseSchema = hasExplicitType ? z2.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+  }
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    const options = schema.oneOf.map((s2) => convertSchema(s2, ctx));
+    const oneOfUnion = z2.xor(options);
+    baseSchema = hasExplicitType ? z2.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+  }
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    if (schema.allOf.length === 0) {
+      baseSchema = hasExplicitType ? baseSchema : z2.any();
+    } else {
+      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+      const startIdx = hasExplicitType ? 0 : 1;
+      for (let i2 = startIdx;i2 < schema.allOf.length; i2++) {
+        result = z2.intersection(result, convertSchema(schema.allOf[i2], ctx));
       }
+      baseSchema = result;
     }
-  };
-}
-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;
+  }
+  if (schema.nullable === true && ctx.version === "openapi-3.0") {
+    baseSchema = z2.nullable(baseSchema);
+  }
+  if (schema.readOnly === true) {
+    baseSchema = z2.readonly(baseSchema);
+  }
+  const extraMeta = {};
+  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
+  for (const key of coreMetadataKeys) {
+    if (key in schema) {
+      extraMeta[key] = schema[key];
     }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      result.set(chunk, offset);
-      offset += chunk.length;
+  }
+  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
+  for (const key of contentMetadataKeys) {
+    if (key in schema) {
+      extraMeta[key] = schema[key];
     }
-    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}".`);
-        }
+  for (const key of Object.keys(schema)) {
+    if (!RECOGNIZED_KEYS.has(key)) {
+      extraMeta[key] = schema[key];
     }
-  })().then(() => controller.finalize()).catch((err) => controller.error(err));
-  return new Uint8Array(await streamToBuffer(readable));
-}
-
-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();
-      }
-    });
+  if (Object.keys(extraMeta).length > 0) {
+    ctx.registry.add(baseSchema, extraMeta);
   }
-  async buffer() {
-    return this._buffer;
+  return baseSchema;
+}
+function fromJSONSchema(schema, params) {
+  if (typeof schema === "boolean") {
+    return schema ? z2.any() : z2.never();
   }
+  const version2 = detectVersion(schema, params?.defaultTarget);
+  const defs = schema.$defs || schema.definitions || {};
+  const ctx = {
+    version: version2,
+    defs,
+    refs: new Map,
+    processing: new Set,
+    rootSchema: schema,
+    registry: params?.registry ?? globalRegistry
+  };
+  return convertSchema(schema, ctx);
 }
-async function archive(files) {
-  const entries = Object.entries(files).map(([name, content]) => {
-    return {
-      header: { name, size: content.length, type: "file" },
-      body: new Uint8Array(content)
-    };
+function string3(params) {
+  return _coercedString(ZodString, params);
+}
+function number3(params) {
+  return _coercedNumber(ZodNumber, params);
+}
+function boolean3(params) {
+  return _coercedBoolean(ZodBoolean, params);
+}
+function bigint3(params) {
+  return _coercedBigint(ZodBigInt, params);
+}
+function date4(params) {
+  return _coercedDate(ZodDate, params);
+}
+function define(input) {
+  if (input === null || typeof input !== "object") {
+    throw new DefinitionError("definition must be an object");
+  }
+  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 ?? validated.version ?? undefined,
+    registry: validated.registry,
+    path: validated.path,
+    description: validated.description,
+    author: validated.author,
+    license: validated.license,
+    keywords: validated.keywords,
+    repository: validated.repository
   });
-  const tarBuffer = await packTar(entries);
-  const gzipBuffer = await gzipAsync(Buffer.from(tarBuffer));
-  return new RXAImpl(gzipBuffer);
+  return rxd;
 }
 function locate(rxm) {
   return {
@@ -4868,6 +4861,15 @@ function locate(rxm) {
     tag: rxm.tag
   };
 }
+function manifest(rxd) {
+  return {
+    registry: rxd.registry,
+    path: rxd.path,
+    name: rxd.name,
+    type: rxd.type,
+    tag: rxd.tag ?? "latest"
+  };
+}
 function resource(rxm, rxa) {
   const rxl = locate(rxm);
   return {
@@ -4877,59 +4879,6 @@ function resource(rxm, rxa) {
   };
 }
 
-class TypeHandlerChain {
-  handlers = new Map;
-  constructor() {
-    for (const type of builtinTypes) {
-      this.registerInternal(type);
-    }
-  }
-  static create() {
-    return new TypeHandlerChain;
-  }
-  registerInternal(type) {
-    this.handlers.set(type.name, type);
-    if (type.aliases) {
-      for (const alias of type.aliases) {
-        this.handlers.set(alias, type);
-      }
-    }
-  }
-  register(type) {
-    if (this.handlers.has(type.name)) {
-      throw new ResourceTypeError(`Type '${type.name}' is already registered`);
-    }
-    this.handlers.set(type.name, type);
-    if (type.aliases) {
-      for (const alias of type.aliases) {
-        if (this.handlers.has(alias)) {
-          throw new ResourceTypeError(`Alias '${alias}' conflicts with existing type or alias`);
-        }
-        this.handlers.set(alias, type);
-      }
-    }
-  }
-  canHandle(typeName) {
-    return this.handlers.has(typeName);
-  }
-  getHandler(typeName) {
-    const handler = this.handlers.get(typeName);
-    if (!handler) {
-      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
-    }
-    return handler;
-  }
-  getHandlerOrUndefined(typeName) {
-    return this.handlers.get(typeName);
-  }
-  getSupportedTypes() {
-    return Array.from(this.handlers.keys());
-  }
-  clear() {
-    this.handlers.clear();
-  }
-}
-
 class FolderLoader {
   async canLoad(source) {
     try {
@@ -4948,7 +4897,7 @@ class FolderLoader {
     const resourceJsonPath = join(folderPath, "resource.json");
     let resourceJson;
     try {
-      resourceJson = await readFile2(resourceJsonPath, "utf-8");
+      resourceJson = await readFile(resourceJsonPath, "utf-8");
     } catch (error48) {
       throw new ResourceXError(`Failed to read resource.json: ${error48 instanceof Error ? error48.message : String(error48)}`);
     }
@@ -4976,6 +4925,40 @@ class FolderLoader {
       if (relativePath === "resource.json") {
         continue;
       }
+      if (entry.isFile()) {
+        files[relativePath] = await readFile(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 stat2(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 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()) {
@@ -5026,6 +5009,7 @@ class MemoryRXAStore {
 
 class MemoryRXMStore {
   manifests = new Map;
+  latestPointers = new Map;
   buildKey(name, tag, registry2) {
     return registry2 ? `${registry2}/${name}:${tag}` : `${name}:${tag}`;
   }
@@ -5078,25 +5062,87 @@ class MemoryRXMStore {
         results = results.filter((m2) => m2.registry === registry2);
       }
     }
-    if (query) {
-      const lowerQuery = query.toLowerCase();
-      results = results.filter((m2) => m2.name.toLowerCase().includes(lowerQuery));
-    }
-    results = results.slice(offset);
-    if (limit !== undefined) {
-      results = results.slice(0, limit);
-    }
-    return results;
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      results = results.filter((m2) => m2.name.toLowerCase().includes(lowerQuery));
+    }
+    results = results.slice(offset);
+    if (limit !== undefined) {
+      results = results.slice(0, limit);
+    }
+    return results;
+  }
+  async deleteByRegistry(registry2) {
+    for (const [key, m2] of this.manifests.entries()) {
+      if (m2.registry === registry2) {
+        this.manifests.delete(key);
+      }
+    }
+  }
+  async setLatest(name, tag, registry2) {
+    const key = registry2 ? `${registry2}/${name}` : name;
+    this.latestPointers.set(key, tag);
+  }
+  async getLatest(name, registry2) {
+    const key = registry2 ? `${registry2}/${name}` : name;
+    return this.latestPointers.get(key) ?? null;
+  }
+  clear() {
+    this.manifests.clear();
+    this.latestPointers.clear();
+  }
+}
+
+class TypeHandlerChain {
+  handlers = new Map;
+  constructor() {
+    for (const type of builtinTypes) {
+      this.registerInternal(type);
+    }
+  }
+  static create() {
+    return new TypeHandlerChain;
+  }
+  registerInternal(type) {
+    this.handlers.set(type.name, type);
+    if (type.aliases) {
+      for (const alias of type.aliases) {
+        this.handlers.set(alias, type);
+      }
+    }
+  }
+  register(type) {
+    if (this.handlers.has(type.name)) {
+      throw new ResourceTypeError(`Type '${type.name}' is already registered`);
+    }
+    this.handlers.set(type.name, type);
+    if (type.aliases) {
+      for (const alias of type.aliases) {
+        if (this.handlers.has(alias)) {
+          throw new ResourceTypeError(`Alias '${alias}' conflicts with existing type or alias`);
+        }
+        this.handlers.set(alias, type);
+      }
+    }
   }
-  async deleteByRegistry(registry2) {
-    for (const [key, m2] of this.manifests.entries()) {
-      if (m2.registry === registry2) {
-        this.manifests.delete(key);
-      }
+  canHandle(typeName) {
+    return this.handlers.has(typeName);
+  }
+  getHandler(typeName) {
+    const handler = this.handlers.get(typeName);
+    if (!handler) {
+      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
     }
+    return handler;
+  }
+  getHandlerOrUndefined(typeName) {
+    return this.handlers.get(typeName);
+  }
+  getSupportedTypes() {
+    return Array.from(this.handlers.keys());
   }
   clear() {
-    this.manifests.clear();
+    this.handlers.clear();
   }
 }
 var __defProp2, __export2 = (target, all) => {
@@ -5107,7 +5153,7 @@ var __defProp2, __export2 = (target, all) => {
       configurable: true,
       set: (newValue) => all[name] = () => newValue
     });
-}, ResourceXError, DefinitionError, 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, gzipAsync, exports_external, exports_core2, NEVER, $brand, $ZodAsyncError, $ZodEncodeError, globalConfig, exports_util, EVALUATING, captureStackTrace, allowsEval, getParsedType = (data) => {
   const t2 = typeof data;
   switch (t2) {
     case "undefined":
@@ -10785,21 +10831,28 @@ var __defProp2, __export2 = (target, all) => {
   Codec: ZodCodec,
   Boolean: ZodBoolean,
   String: ZodString
-}, ...args), ZodIssueCode, ZodFirstPartyTypeKind, z2, RECOGNIZED_KEYS, exports_coerce, RXDSchema, 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, gzipAsync, gunzipAsync, ResourceTypeError, textType, jsonType, binaryType, skillType, builtinTypes, RegistryError;
+}, ...args), ZodIssueCode, ZodFirstPartyTypeKind, z2, RECOGNIZED_KEYS, exports_coerce, ResourceXError, DefinitionError, RXDSchema, gunzipAsync, RegistryError, textType, jsonType, binaryType, skillType, builtinTypes, ResourceTypeError;
 var init_dist = __esm(() => {
   __defProp2 = Object.defineProperty;
-  ResourceXError = class ResourceXError extends Error {
-    constructor(message, options) {
-      super(message, options);
-      this.name = "ResourceXError";
-    }
-  };
-  DefinitionError = class DefinitionError extends ResourceXError {
-    constructor(message) {
-      super(message);
-      this.name = "DefinitionError";
-    }
+  TYPEFLAG = {
+    file: "0",
+    link: "1",
+    symlink: "2",
+    "character-device": "3",
+    "block-device": "4",
+    directory: "5",
+    fifo: "6",
+    "pax-header": "x",
+    "pax-global-header": "g",
+    "gnu-long-name": "L",
+    "gnu-long-link-name": "K"
   };
+  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,
@@ -14761,6 +14814,18 @@ var init_dist = __esm(() => {
     bigint: () => bigint3
   });
   config(en_default());
+  ResourceXError = class ResourceXError extends Error {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "ResourceXError";
+    }
+  };
+  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),
@@ -14774,30 +14839,11 @@ var init_dist = __esm(() => {
     keywords: exports_external.array(exports_external.string().max(64)).max(20).optional(),
     repository: exports_external.string().max(256).optional()
   }).strict();
-  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);
   gunzipAsync = promisify2(gunzip);
-  ResourceTypeError = class ResourceTypeError extends ResourceXError {
-    constructor(message) {
-      super(message);
-      this.name = "ResourceTypeError";
+  RegistryError = class RegistryError extends ResourceXError {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "RegistryError";
     }
   };
   textType = {
@@ -14887,10 +14933,10 @@ var skill_type_default = {
     }
   };
   builtinTypes = [textType, jsonType, binaryType, skillType];
-  RegistryError = class RegistryError extends ResourceXError {
-    constructor(message, options) {
-      super(message, options);
-      this.name = "RegistryError";
+  ResourceTypeError = class ResourceTypeError extends ResourceXError {
+    constructor(message) {
+      super(message);
+      this.name = "ResourceTypeError";
     }
   };
 });
@@ -14902,14 +14948,14 @@ __export(exports_dist, {
   FileSystemRXMStore: () => FileSystemRXMStore,
   FileSystemRXAStore: () => FileSystemRXAStore
 });
-import { homedir } from "os";
-import { join as join3 } from "path";
-import { mkdir, writeFile, unlink, readdir as readdir2, stat as stat2 } from "fs/promises";
-import { createReadStream } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { join as join2 } from "path";
-import { mkdir as mkdir2, readFile, writeFile as writeFile2, unlink as unlink2, readdir as readdir22, stat as stat22, rm } from "fs/promises";
+import { createReadStream } from "fs";
+import { mkdir, readdir as readdir3, stat as stat3, unlink, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+import { mkdir as mkdir2, readdir as readdir22, readFile as readFile3, rm, stat as stat22, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 import { join as join22 } from "path";
+import { homedir } from "os";
+import { join as join32 } from "path";
 
 class FileSystemRXAStore {
   basePath;
@@ -14918,7 +14964,7 @@ class FileSystemRXAStore {
   }
   getPath(digest) {
     const prefix = digest.substring(7, 9);
-    return join2(this.basePath, prefix, digest);
+    return join3(this.basePath, prefix, digest);
   }
   async get(digest) {
     if (!isValidDigest(digest)) {
@@ -14930,6 +14976,8 @@ class FileSystemRXAStore {
     const readStream = createReadStream(path);
     await new Promise((resolve, reject) => {
       readStream.on("data", (chunk) => {
+        if (typeof chunk === "string")
+          chunk = Buffer.from(chunk);
         chunks.push(chunk);
         hash2.update(chunk);
       });
@@ -14948,7 +14996,7 @@ class FileSystemRXAStore {
     if (await this.has(digest)) {
       return digest;
     }
-    const dir = join2(path, "..");
+    const dir = join3(path, "..");
     await mkdir(dir, { recursive: true });
     await writeFile(path, data);
     return digest;
@@ -14956,7 +15004,7 @@ class FileSystemRXAStore {
   async has(digest) {
     const path = this.getPath(digest);
     try {
-      await stat2(path);
+      await stat3(path);
       return true;
     } catch {
       return false;
@@ -14971,11 +15019,11 @@ class FileSystemRXAStore {
   async list() {
     const digests = [];
     try {
-      const prefixes = await readdir2(this.basePath);
+      const prefixes = await readdir3(this.basePath);
       for (const prefix of prefixes) {
-        const prefixPath = join2(this.basePath, prefix);
+        const prefixPath = join3(this.basePath, prefix);
         try {
-          const files = await readdir2(prefixPath);
+          const files = await readdir3(prefixPath);
           for (const file2 of files) {
             if (file2.startsWith("sha256:")) {
               digests.push(file2);
@@ -15003,7 +15051,7 @@ class FileSystemRXMStore {
   async get(name, tag, registry2) {
     const path = this.getPath(name, tag, registry2);
     try {
-      const data = await readFile(path, "utf-8");
+      const data = await readFile3(path, "utf-8");
       return JSON.parse(data);
     } catch {
       return null;
@@ -15043,6 +15091,19 @@ class FileSystemRXMStore {
     } catch {}
     return tags;
   }
+  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");
+  }
+  async getLatest(name, registry2) {
+    const dir = this.getDir(name, registry2);
+    try {
+      return (await readFile3(join22(dir, LATEST_FILE), "utf-8")).trim();
+    } catch {
+      return null;
+    }
+  }
   async listNames(registry2, query) {
     const registryDir = registry2 ?? LOCAL_DIR;
     const basePath = join22(this.basePath, registryDir);
@@ -15092,7 +15153,7 @@ class FileSystemRXMStore {
             for (const file2 of files) {
               if (file2.endsWith(".json")) {
                 const filePath = join22(namePath, file2);
-                const data = await readFile(filePath, "utf-8");
+                const data = await readFile3(filePath, "utf-8");
                 const manifest2 = JSON.parse(data);
                 results.push(manifest2);
               }
@@ -15120,15 +15181,18 @@ class NodeProvider {
   createStores(config2) {
     const basePath = config2.path ?? DEFAULT_BASE_PATH;
     return {
-      rxaStore: new FileSystemRXAStore(join3(basePath, "blobs")),
-      rxmStore: new FileSystemRXMStore(join3(basePath, "manifests"))
+      rxaStore: new FileSystemRXAStore(join32(basePath, "blobs")),
+      rxmStore: new FileSystemRXMStore(join32(basePath, "manifests"))
     };
   }
   createLoader(_config) {
     return new FolderLoader;
   }
+  createSourceLoader(_config) {
+    return new FolderSourceLoader;
+  }
 }
-var LOCAL_DIR = "_local", DEFAULT_BASE_PATH;
+var LOCAL_DIR = "_local", LATEST_FILE = ".latest", DEFAULT_BASE_PATH;
 var init_dist2 = __esm(() => {
   init_dist();
   init_dist();
@@ -15624,12 +15688,12 @@ var init_dist3 = __esm(() => {
       }
     }
     get headers() {
-      const cache = this[cacheKey];
-      if (cache) {
-        if (!(cache[2] instanceof Headers)) {
-          cache[2] = new Headers(cache[2]);
+      const cache2 = this[cacheKey];
+      if (cache2) {
+        if (!(cache2[2] instanceof Headers)) {
+          cache2[2] = new Headers(cache2[2]);
         }
-        return cache[2];
+        return cache2[2];
       }
       return this[getResponseCache]().headers;
     }
@@ -17068,14 +17132,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.RX_HOME || join4(homedir2(), ".resourcex");
+import { join as join5 } from "path";
+var RX_HOME = process.env.RX_HOME || join5(homedir2(), ".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: join5(RX_HOME, "config.json"),
+  local: join5(RX_HOME, "local"),
+  cache: join5(RX_HOME, "cache"),
+  linked: join5(RX_HOME, "linked")
 };
 
 // src/lib/config.ts
@@ -17087,11 +17151,22 @@ async function getConfig() {
       fileConfig = await file2.json();
     }
   } catch {}
+  if (fileConfig.registry && !fileConfig.registries) {
+    fileConfig.registries = [{ name: "default", url: fileConfig.registry, default: true }];
+    delete fileConfig.registry;
+  }
   const envRegistry = process.env.RX_REGISTRY;
-  const registry2 = envRegistry !== undefined ? envRegistry || undefined : fileConfig.registry;
+  let registry2;
+  if (envRegistry !== undefined) {
+    registry2 = envRegistry || undefined;
+  } else {
+    const defaultEntry = fileConfig.registries?.find((r3) => r3.default);
+    registry2 = defaultEntry?.url;
+  }
   return {
     path: process.env.RX_HOME || fileConfig.path || RX_HOME,
-    registry: registry2
+    registry: registry2,
+    registries: fileConfig.registries ?? []
   };
 }
 async function setConfig(key, value) {
@@ -17100,6 +17175,73 @@ async function setConfig(key, value) {
   await Bun.$`mkdir -p ${RX_HOME}`.quiet();
   await Bun.write(PATHS.config, JSON.stringify(config2, null, 2));
 }
+async function readRawConfig() {
+  try {
+    const file2 = Bun.file(PATHS.config);
+    if (await file2.exists()) {
+      return await file2.json();
+    }
+  } catch {}
+  return {};
+}
+async function writeConfig(config2) {
+  await Bun.$`mkdir -p ${RX_HOME}`.quiet();
+  const { registry: _3, ...toWrite } = config2;
+  await Bun.write(PATHS.config, JSON.stringify(toWrite, null, 2));
+}
+function migrateConfig(config2) {
+  if (config2.registry && !config2.registries) {
+    config2.registries = [{ name: "default", url: config2.registry, default: true }];
+    delete config2.registry;
+  }
+  return config2;
+}
+async function addRegistry(name, url2, setDefault) {
+  const raw = migrateConfig(await readRawConfig());
+  const registries = raw.registries ?? [];
+  if (registries.some((r3) => r3.name === name)) {
+    throw new Error(`Registry "${name}" already exists`);
+  }
+  const isDefault = setDefault || registries.length === 0;
+  if (isDefault) {
+    for (const r3 of registries)
+      r3.default = false;
+  }
+  registries.push({ name, url: url2, default: isDefault });
+  raw.registries = registries;
+  await writeConfig(raw);
+}
+async function removeRegistry(name) {
+  const raw = migrateConfig(await readRawConfig());
+  const registries = raw.registries ?? [];
+  const idx = registries.findIndex((r3) => r3.name === name);
+  if (idx === -1) {
+    throw new Error(`Registry "${name}" not found`);
+  }
+  registries.splice(idx, 1);
+  raw.registries = registries;
+  await writeConfig(raw);
+}
+async function setDefaultRegistry(name) {
+  const raw = migrateConfig(await readRawConfig());
+  const registries = raw.registries ?? [];
+  const entry = registries.find((r3) => r3.name === name);
+  if (!entry) {
+    throw new Error(`Registry "${name}" not found`);
+  }
+  for (const r3 of registries)
+    r3.default = r3.name === name;
+  raw.registries = registries;
+  await writeConfig(raw);
+}
+async function getRegistries() {
+  const raw = migrateConfig(await readRawConfig());
+  return raw.registries ?? [];
+}
+async function getRegistryByName(name) {
+  const registries = await getRegistries();
+  return registries.find((r3) => r3.name === name);
+}
 
 // src/lib/client.ts
 setProvider(new NodeProvider);
@@ -17144,36 +17286,93 @@ var add = defineCommand({
   }
 });
 
-// src/commands/list.ts
-var list = defineCommand({
+// src/commands/cache.ts
+var clear = defineCommand({
   meta: {
-    name: "list",
-    description: "List local resources"
+    name: "clear",
+    description: "Clear all cached resources"
   },
   args: {
-    query: {
-      type: "positional",
-      description: "Optional search query",
-      required: false
+    registry: {
+      type: "string",
+      alias: "r",
+      description: "Only clear resources from this registry"
     }
   },
   async run({ args }) {
     try {
       const rx = await getClient();
-      const results = await rx.search(args.query);
-      if (results.length === 0) {
-        consola.info("No resources found");
-        return;
-      }
-      consola.info(`Found ${results.length} resource(s):
-`);
-      for (const locator of results) {
-        console.log(`  ${locator}`);
+      await rx.clearCache(args.registry);
+      if (args.registry) {
+        consola.success(`Cleared cache for registry: ${args.registry}`);
+      } else {
+        consola.success("Cleared all cached resources");
       }
     } catch (error48) {
-      consola.error(error48 instanceof Error ? error48.message : "Failed to list resources");
+      consola.error(error48 instanceof Error ? error48.message : "Failed to clear cache");
+      process.exit(1);
+    }
+  }
+});
+var cache = defineCommand({
+  meta: {
+    name: "cache",
+    description: "Manage cached resources"
+  },
+  subCommands: {
+    clear
+  }
+});
+
+// src/commands/config.ts
+var set2 = defineCommand({
+  meta: {
+    name: "set",
+    description: "Set configuration value"
+  },
+  args: {
+    key: {
+      type: "positional",
+      description: "Configuration key (path, registry)",
+      required: true
+    },
+    value: {
+      type: "positional",
+      description: "Configuration value",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const validKeys = ["path", "registry"];
+    if (!validKeys.includes(args.key)) {
+      consola.error(`Invalid key: ${args.key}. Valid keys: ${validKeys.join(", ")}`);
       process.exit(1);
     }
+    await setConfig(args.key, args.value);
+    consola.success(`Set ${args.key} = ${args.value}`);
+  }
+});
+var list = defineCommand({
+  meta: {
+    name: "list",
+    description: "List configuration"
+  },
+  async run() {
+    const config2 = await getConfig();
+    consola.info(`Configuration:
+`);
+    console.log(`  path:     ${config2.path}`);
+    console.log(`  registry: ${config2.registry || "(not set)"}`);
+  }
+});
+var config2 = defineCommand({
+  meta: {
+    name: "config",
+    description: "Manage CLI configuration"
+  },
+  subCommands: {
+    set: set2,
+    list
   }
 });
 
@@ -17250,41 +17449,80 @@ function printFileTree(files) {
       console.log(`      ${prefix}${item}`);
     }
   }
-}
-function printSubTree(files, indent) {
-  for (let i2 = 0;i2 < files.length; i2++) {
-    const file2 = files[i2];
-    const isLast = i2 === files.length - 1;
-    const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-    console.log(`      ${indent}${prefix}${file2}`);
-  }
-}
+}
+function printSubTree(files, indent) {
+  for (let i2 = 0;i2 < files.length; i2++) {
+    const file2 = files[i2];
+    const isLast = i2 === files.length - 1;
+    const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    console.log(`      ${indent}${prefix}${file2}`);
+  }
+}
+
+// src/commands/list.ts
+var list2 = defineCommand({
+  meta: {
+    name: "list",
+    description: "List local resources"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Optional search query",
+      required: false
+    }
+  },
+  async run({ args }) {
+    try {
+      const rx = await getClient();
+      const results = await rx.search(args.query);
+      if (results.length === 0) {
+        consola.info("No resources found");
+        return;
+      }
+      consola.info(`Found ${results.length} resource(s):
+`);
+      for (const locator of results) {
+        console.log(`  ${locator}`);
+      }
+    } catch (error48) {
+      consola.error(error48 instanceof Error ? error48.message : "Failed to list resources");
+      process.exit(1);
+    }
+  }
+});
 
-// src/commands/remove.ts
-var remove = defineCommand({
+// src/commands/pull.ts
+var pull = defineCommand({
   meta: {
-    name: "remove",
-    description: "Remove resource from local storage"
+    name: "pull",
+    description: "Pull resource from remote registry to local cache"
   },
   args: {
     locator: {
       type: "positional",
       description: "Resource locator (e.g., hello.text@1.0.0)",
       required: true
+    },
+    registry: {
+      type: "string",
+      alias: "r",
+      description: "Registry URL (overrides config)"
     }
   },
   async run({ args }) {
     try {
-      const rx = await getClient();
-      const exists = await rx.has(args.locator);
-      if (!exists) {
-        consola.warn(`Resource not found: ${args.locator}`);
-        return;
+      const config3 = await getConfig();
+      const registryUrl = args.registry ?? config3.registry;
+      if (!registryUrl) {
+        consola.error("No registry configured. Use: rx config set registry <url> or --registry <url>");
+        process.exit(1);
       }
-      await rx.remove(args.locator);
-      consola.success(`Removed: ${args.locator}`);
+      const rx = await getClient({ registry: registryUrl });
+      await rx.pull(args.locator);
+      consola.success(`Pulled: ${args.locator}`);
     } catch (error48) {
-      consola.error(error48 instanceof Error ? error48.message : "Failed to remove resource");
+      consola.error(error48 instanceof Error ? error48.message : "Failed to pull resource");
       process.exit(1);
     }
   }
@@ -17305,15 +17543,21 @@ var push = defineCommand({
     registry: {
       type: "string",
       alias: "r",
-      description: "Registry URL (overrides config)"
+      description: "Registry name or URL (overrides default)"
     }
   },
   async run({ args }) {
     try {
-      const config2 = await getConfig();
-      const registryUrl = args.registry ?? config2.registry;
+      let registryUrl;
+      if (args.registry) {
+        const entry = await getRegistryByName(args.registry);
+        registryUrl = entry ? entry.url : args.registry;
+      } else {
+        const config3 = await getConfig();
+        registryUrl = config3.registry;
+      }
       if (!registryUrl) {
-        consola.error("No registry configured. Use: rx config set registry <url> or --registry <url>");
+        consola.error("No registry configured. Use: rx registry add <name> <url> or --registry <name|url>");
         process.exit(1);
       }
       const rx = await getClient({ registry: registryUrl });
@@ -17326,37 +17570,143 @@ var push = defineCommand({
   }
 });
 
-// src/commands/pull.ts
-var pull = defineCommand({
+// src/commands/registry.ts
+var add2 = defineCommand({
   meta: {
-    name: "pull",
-    description: "Pull resource from remote registry to local cache"
+    name: "add",
+    description: "Add a registry"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Registry name",
+      required: true
+    },
+    url: {
+      type: "positional",
+      description: "Registry URL",
+      required: true
+    },
+    default: {
+      type: "boolean",
+      description: "Set as default registry",
+      default: false
+    }
+  },
+  async run({ args }) {
+    try {
+      await addRegistry(args.name, args.url, args.default);
+      const registries = await getRegistries();
+      const entry = registries.find((r3) => r3.name === args.name);
+      const marker = entry?.default ? " (default)" : "";
+      consola.success(`Added registry: ${args.name} \u2192 ${args.url}${marker}`);
+    } catch (error48) {
+      consola.error(error48 instanceof Error ? error48.message : "Failed to add registry");
+      process.exit(1);
+    }
+  }
+});
+var remove = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Remove a registry"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Registry name",
+      required: true
+    }
+  },
+  async run({ args }) {
+    try {
+      await removeRegistry(args.name);
+      consola.success(`Removed registry: ${args.name}`);
+    } catch (error48) {
+      consola.error(error48 instanceof Error ? error48.message : "Failed to remove registry");
+      process.exit(1);
+    }
+  }
+});
+var listCmd = defineCommand({
+  meta: {
+    name: "list",
+    description: "List all configured registries"
+  },
+  async run() {
+    const registries = await getRegistries();
+    if (registries.length === 0) {
+      consola.info("No registries configured. Use: rx registry add <name> <url>");
+      return;
+    }
+    consola.info(`Registries:
+`);
+    for (const r3 of registries) {
+      const marker = r3.default ? " (default)" : "";
+      console.log(`  ${r3.name}	${r3.url}${marker}`);
+    }
+  }
+});
+var defaultCmd = defineCommand({
+  meta: {
+    name: "default",
+    description: "Set default registry"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Registry name",
+      required: true
+    }
+  },
+  async run({ args }) {
+    try {
+      await setDefaultRegistry(args.name);
+      consola.success(`Default registry set to: ${args.name}`);
+    } catch (error48) {
+      consola.error(error48 instanceof Error ? error48.message : "Failed to set default");
+      process.exit(1);
+    }
+  }
+});
+var registry2 = defineCommand({
+  meta: {
+    name: "registry",
+    description: "Manage registry configurations"
+  },
+  subCommands: {
+    add: add2,
+    remove,
+    list: listCmd,
+    default: defaultCmd
+  }
+});
+
+// src/commands/remove.ts
+var remove2 = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Remove resource from local storage"
   },
   args: {
     locator: {
       type: "positional",
       description: "Resource locator (e.g., hello.text@1.0.0)",
       required: true
-    },
-    registry: {
-      type: "string",
-      alias: "r",
-      description: "Registry URL (overrides config)"
     }
   },
   async run({ args }) {
     try {
-      const config2 = await getConfig();
-      const registryUrl = args.registry ?? config2.registry;
-      if (!registryUrl) {
-        consola.error("No registry configured. Use: rx config set registry <url> or --registry <url>");
-        process.exit(1);
+      const rx = await getClient();
+      const exists = await rx.has(args.locator);
+      if (!exists) {
+        consola.warn(`Resource not found: ${args.locator}`);
+        return;
       }
-      const rx = await getClient({ registry: registryUrl });
-      await rx.pull(args.locator);
-      consola.success(`Pulled: ${args.locator}`);
+      await rx.remove(args.locator);
+      consola.success(`Removed: ${args.locator}`);
     } catch (error48) {
-      consola.error(error48 instanceof Error ? error48.message : "Failed to pull resource");
+      consola.error(error48 instanceof Error ? error48.message : "Failed to remove resource");
       process.exit(1);
     }
   }
@@ -17383,12 +17733,12 @@ var search = defineCommand({
   },
   async run({ args }) {
     try {
-      const config2 = await getConfig();
-      if (!config2.registry) {
+      const config3 = await getConfig();
+      if (!config3.registry) {
         consola.error("No registry configured. Use: rx config set registry <url>");
         process.exit(1);
       }
-      const url2 = buildSearchUrl(config2.registry, {
+      const url2 = buildSearchUrl(config3.registry, {
         q: args.query,
         limit: Number(args.limit)
       });
@@ -17416,90 +17766,6 @@ var search = defineCommand({
   }
 });
 
-// src/commands/use.ts
-var use = defineCommand({
-  meta: {
-    name: "use",
-    description: "Use and execute resource"
-  },
-  args: {
-    locator: {
-      type: "positional",
-      description: "Resource locator (e.g., hello.text@1.0.0)",
-      required: true
-    }
-  },
-  async run({ args }) {
-    try {
-      const rx = await getClient();
-      const executable = await rx.use(args.locator);
-      const result = await executable.execute();
-      if (typeof result === "string") {
-        console.log(result);
-      } else if (result instanceof Uint8Array) {
-        process.stdout.write(result);
-      } else {
-        console.log(JSON.stringify(result, null, 2));
-      }
-    } catch (error48) {
-      consola.error(error48 instanceof Error ? error48.message : "Failed to use resource");
-      process.exit(1);
-    }
-  }
-});
-
-// src/commands/config.ts
-var set2 = defineCommand({
-  meta: {
-    name: "set",
-    description: "Set configuration value"
-  },
-  args: {
-    key: {
-      type: "positional",
-      description: "Configuration key (path, registry)",
-      required: true
-    },
-    value: {
-      type: "positional",
-      description: "Configuration value",
-      required: true
-    }
-  },
-  async run({ args }) {
-    const validKeys = ["path", "registry"];
-    if (!validKeys.includes(args.key)) {
-      consola.error(`Invalid key: ${args.key}. Valid keys: ${validKeys.join(", ")}`);
-      process.exit(1);
-    }
-    await setConfig(args.key, args.value);
-    consola.success(`Set ${args.key} = ${args.value}`);
-  }
-});
-var list2 = defineCommand({
-  meta: {
-    name: "list",
-    description: "List configuration"
-  },
-  async run() {
-    const config2 = await getConfig();
-    consola.info(`Configuration:
-`);
-    console.log(`  path:     ${config2.path}`);
-    console.log(`  registry: ${config2.registry || "(not set)"}`);
-  }
-});
-var config2 = defineCommand({
-  meta: {
-    name: "config",
-    description: "Manage CLI configuration"
-  },
-  subCommands: {
-    set: set2,
-    list: list2
-  }
-});
-
 // src/commands/server.ts
 import { join as join6 } from "path";
 var server = defineCommand({
@@ -17548,43 +17814,36 @@ var server = defineCommand({
   }
 });
 
-// src/commands/cache.ts
-var clear = defineCommand({
+// src/commands/use.ts
+var ingest = defineCommand({
   meta: {
-    name: "clear",
-    description: "Clear all cached resources"
+    name: "ingest",
+    description: "Ingest and execute resource from any source (directory path or locator)"
   },
   args: {
-    registry: {
-      type: "string",
-      alias: "r",
-      description: "Only clear resources from this registry"
+    source: {
+      type: "positional",
+      description: "Resource source (directory path or locator, e.g., ./my-skill or hello:1.0.0)",
+      required: true
     }
   },
   async run({ args }) {
     try {
       const rx = await getClient();
-      await rx.clearCache(args.registry);
-      if (args.registry) {
-        consola.success(`Cleared cache for registry: ${args.registry}`);
+      const result = await rx.ingest(args.source);
+      if (typeof result === "string") {
+        console.log(result);
+      } else if (result instanceof Uint8Array) {
+        process.stdout.write(result);
       } else {
-        consola.success("Cleared all cached resources");
+        console.log(JSON.stringify(result, null, 2));
       }
     } catch (error48) {
-      consola.error(error48 instanceof Error ? error48.message : "Failed to clear cache");
+      consola.error(error48 instanceof Error ? error48.message : "Failed to ingest resource");
       process.exit(1);
     }
   }
 });
-var cache = defineCommand({
-  meta: {
-    name: "cache",
-    description: "Manage cached resources"
-  },
-  subCommands: {
-    clear
-  }
-});
 
 // src/index.ts
 var main = defineCommand({
@@ -17595,18 +17854,19 @@ var main = defineCommand({
   },
   subCommands: {
     add,
-    list,
+    list: list2,
     info,
-    remove,
+    remove: remove2,
     push,
     pull,
     search,
-    use,
+    ingest,
     config: config2,
+    registry: registry2,
     cache,
     server
   }
 });
 runMain(main);
 
-//# debugId=BC9BE61BDA75B33264756E2164756E21
+//# debugId=0E33A1E8B726679564756E2164756E21