@resourcexjs/cli 2.14.1 → 2.16.0

package/dist/index.js

@@ -1,6 +1,21 @@
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -774,374 +789,9 @@ import { promisify } from "util";
 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 { 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 writeString(view, offset, size, value) {
-  if (value)
-    encoder.encodeInto(value, view.subarray(offset, offset + size));
-}
-function writeOctal(view, offset, size, value) {
-  if (value === undefined)
-    return;
-  const octalString = value.toString(8).padStart(size - 1, "0");
-  encoder.encodeInto(octalString, view.subarray(offset, offset + size - 1));
-}
-async function normalizeBody(body) {
-  if (body === null || body === undefined)
-    return EMPTY;
-  if (body instanceof Uint8Array)
-    return body;
-  if (typeof body === "string")
-    return encoder.encode(body);
-  if (body instanceof ArrayBuffer)
-    return new Uint8Array(body);
-  if (body instanceof Blob)
-    return new Uint8Array(await body.arrayBuffer());
-  throw new TypeError("Unsupported content type for entry body.");
-}
-function writeChecksum(block) {
-  block.fill(CHECKSUM_SPACE, USTAR_CHECKSUM_OFFSET, USTAR_CHECKSUM_OFFSET + USTAR_CHECKSUM_SIZE);
-  let checksum = 0;
-  for (const byte of block)
-    checksum += byte;
-  for (let i2 = USTAR_CHECKSUM_OFFSET + 6 - 1;i2 >= USTAR_CHECKSUM_OFFSET; i2--) {
-    block[i2] = (checksum & 7) + ASCII_ZERO;
-    checksum >>= 3;
-  }
-  block[USTAR_CHECKSUM_OFFSET + 6] = 0;
-  block[USTAR_CHECKSUM_OFFSET + 7] = CHECKSUM_SPACE;
-}
-function generatePax(header) {
-  const paxRecords = {};
-  if (header.name.length > USTAR_NAME_SIZE) {
-    if (findUstarSplit(header.name) === null)
-      paxRecords.path = header.name;
-  }
-  if (header.linkname && header.linkname.length > USTAR_NAME_SIZE)
-    paxRecords.linkpath = header.linkname;
-  if (header.uname && header.uname.length > USTAR_UNAME_SIZE)
-    paxRecords.uname = header.uname;
-  if (header.gname && header.gname.length > USTAR_GNAME_SIZE)
-    paxRecords.gname = header.gname;
-  if (header.uid != null && header.uid > USTAR_MAX_UID_GID)
-    paxRecords.uid = String(header.uid);
-  if (header.gid != null && header.gid > USTAR_MAX_UID_GID)
-    paxRecords.gid = String(header.gid);
-  if (header.size != null && header.size > USTAR_MAX_SIZE)
-    paxRecords.size = String(header.size);
-  if (header.pax)
-    Object.assign(paxRecords, header.pax);
-  const paxEntries = Object.entries(paxRecords);
-  if (paxEntries.length === 0)
-    return null;
-  const paxBody = encoder.encode(paxEntries.map(([key, value]) => {
-    const record = `${key}=${value}
-`;
-    const partLength = encoder.encode(record).length + 1;
-    let totalLength = partLength + String(partLength).length;
-    totalLength = partLength + String(totalLength).length;
-    return `${totalLength} ${record}`;
-  }).join(""));
-  return {
-    paxHeader: createTarHeader({
-      name: decoder.decode(encoder.encode(`PaxHeader/${header.name}`).slice(0, 100)),
-      size: paxBody.length,
-      type: "pax-header",
-      mode: 420,
-      mtime: header.mtime,
-      uname: header.uname,
-      gname: header.gname,
-      uid: header.uid,
-      gid: header.gid
-    }),
-    paxBody
-  };
-}
-function findUstarSplit(path) {
-  if (path.length <= USTAR_NAME_SIZE)
-    return null;
-  const minSlashIndex = path.length - USTAR_NAME_SIZE - 1;
-  const slashIndex = path.lastIndexOf("/", USTAR_PREFIX_SIZE);
-  if (slashIndex > 0 && slashIndex >= minSlashIndex)
-    return {
-      prefix: path.slice(0, slashIndex),
-      name: path.slice(slashIndex + 1)
-    };
-  return null;
-}
-function createTarHeader(header) {
-  const view = new Uint8Array(BLOCK_SIZE);
-  const size = isBodyless(header) ? 0 : header.size ?? 0;
-  let name = header.name;
-  let prefix = "";
-  if (!header.pax?.path) {
-    const split = findUstarSplit(name);
-    if (split) {
-      name = split.name;
-      prefix = split.prefix;
-    }
-  }
-  writeString(view, USTAR_NAME_OFFSET, USTAR_NAME_SIZE, name);
-  writeOctal(view, USTAR_MODE_OFFSET, USTAR_MODE_SIZE, header.mode ?? (header.type === DIRECTORY ? DEFAULT_DIR_MODE : DEFAULT_FILE_MODE));
-  writeOctal(view, USTAR_UID_OFFSET, USTAR_UID_SIZE, header.uid ?? 0);
-  writeOctal(view, USTAR_GID_OFFSET, USTAR_GID_SIZE, header.gid ?? 0);
-  writeOctal(view, USTAR_SIZE_OFFSET, USTAR_SIZE_SIZE, size);
-  writeOctal(view, USTAR_MTIME_OFFSET, USTAR_MTIME_SIZE, Math.floor((header.mtime?.getTime() ?? Date.now()) / 1000));
-  writeString(view, USTAR_TYPEFLAG_OFFSET, USTAR_TYPEFLAG_SIZE, TYPEFLAG[header.type ?? FILE]);
-  writeString(view, USTAR_LINKNAME_OFFSET, USTAR_LINKNAME_SIZE, header.linkname);
-  writeString(view, USTAR_MAGIC_OFFSET, USTAR_MAGIC_SIZE, "ustar\x00");
-  writeString(view, USTAR_VERSION_OFFSET, USTAR_VERSION_SIZE, USTAR_VERSION);
-  writeString(view, USTAR_UNAME_OFFSET, USTAR_UNAME_SIZE, header.uname);
-  writeString(view, USTAR_GNAME_OFFSET, USTAR_GNAME_SIZE, header.gname);
-  writeString(view, USTAR_PREFIX_OFFSET, USTAR_PREFIX_SIZE, prefix);
-  writeChecksum(view);
-  return view;
-}
-function getHeaderBlocks(header) {
-  const base = createTarHeader(header);
-  const pax = generatePax(header);
-  if (!pax)
-    return [base];
-  const paxPadding = -pax.paxBody.length & BLOCK_SIZE_MASK;
-  const paddingBlocks = paxPadding > 0 ? [ZERO_BLOCK.subarray(0, paxPadding)] : [];
-  return [
-    pax.paxHeader,
-    pax.paxBody,
-    ...paddingBlocks,
-    base
-  ];
-}
-function createTarPacker(onData, onError, onFinalize) {
-  let currentHeader = null;
-  let bytesWritten = 0;
-  let finalized = false;
-  return {
-    add(header) {
-      if (finalized) {
-        const error = /* @__PURE__ */ new Error("No new tar entries after finalize.");
-        onError(error);
-        throw error;
-      }
-      if (currentHeader !== null) {
-        const error = /* @__PURE__ */ new Error("Previous entry must be completed before adding a new one");
-        onError(error);
-        throw error;
-      }
-      try {
-        const size = isBodyless(header) ? 0 : header.size ?? 0;
-        const headerBlocks = getHeaderBlocks({
-          ...header,
-          size
-        });
-        for (const block of headerBlocks)
-          onData(block);
-        currentHeader = {
-          ...header,
-          size
-        };
-        bytesWritten = 0;
-      } catch (error) {
-        onError(error);
-      }
-    },
-    write(chunk) {
-      if (!currentHeader) {
-        const error = /* @__PURE__ */ new Error("No active tar entry.");
-        onError(error);
-        throw error;
-      }
-      if (finalized) {
-        const error = /* @__PURE__ */ new Error("Cannot write data after finalize.");
-        onError(error);
-        throw error;
-      }
-      const newTotal = bytesWritten + chunk.length;
-      if (newTotal > currentHeader.size) {
-        const error = /* @__PURE__ */ new Error(`"${currentHeader.name}" exceeds given size of ${currentHeader.size} bytes.`);
-        onError(error);
-        throw error;
-      }
-      try {
-        bytesWritten = newTotal;
-        onData(chunk);
-      } catch (error) {
-        onError(error);
-      }
-    },
-    endEntry() {
-      if (!currentHeader) {
-        const error = /* @__PURE__ */ new Error("No active entry to end.");
-        onError(error);
-        throw error;
-      }
-      if (finalized) {
-        const error = /* @__PURE__ */ new Error("Cannot end entry after finalize.");
-        onError(error);
-        throw error;
-      }
-      try {
-        if (bytesWritten !== currentHeader.size) {
-          const error = /* @__PURE__ */ new Error(`Size mismatch for "${currentHeader.name}".`);
-          onError(error);
-          throw error;
-        }
-        const paddingSize = -currentHeader.size & BLOCK_SIZE_MASK;
-        if (paddingSize > 0)
-          onData(new Uint8Array(paddingSize));
-        currentHeader = null;
-        bytesWritten = 0;
-      } catch (error) {
-        onError(error);
-        throw error;
-      }
-    },
-    finalize() {
-      if (finalized) {
-        const error = /* @__PURE__ */ new Error("Archive has already been finalized");
-        onError(error);
-        throw error;
-      }
-      if (currentHeader !== null) {
-        const error = /* @__PURE__ */ new Error("Cannot finalize while an entry is still active");
-        onError(error);
-        throw error;
-      }
-      try {
-        onData(EOF_BUFFER);
-        finalized = true;
-        if (onFinalize)
-          onFinalize();
-      } catch (error) {
-        onError(error);
-      }
-    }
-  };
-}
-function createTarPacker2() {
-  let streamController;
-  let packer;
-  return {
-    readable: new ReadableStream({ start(controller) {
-      streamController = controller;
-      packer = createTarPacker(controller.enqueue.bind(controller), controller.error.bind(controller), controller.close.bind(controller));
-    } }),
-    controller: {
-      add(header) {
-        const bodyless = isBodyless(header);
-        const h2 = { ...header };
-        if (bodyless)
-          h2.size = 0;
-        packer.add(h2);
-        if (bodyless)
-          packer.endEntry();
-        return new WritableStream({
-          write(chunk) {
-            packer.write(chunk);
-          },
-          close() {
-            if (!bodyless)
-              packer.endEntry();
-          },
-          abort(reason) {
-            streamController.error(reason);
-          }
-        });
-      },
-      finalize() {
-        packer.finalize();
-      },
-      error(err) {
-        streamController.error(err);
-      }
-    }
-  };
-}
-async function streamToBuffer(stream) {
-  const chunks = [];
-  const reader = stream.getReader();
-  let totalLength = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      chunks.push(value);
-      totalLength += value.length;
-    }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      result.set(chunk, offset);
-      offset += chunk.length;
-    }
-    return result;
-  } finally {
-    reader.releaseLock();
-  }
-}
-async function packTar(entries) {
-  const { readable, controller } = createTarPacker2();
-  await (async () => {
-    for (const entry of entries) {
-      const entryStream = controller.add(entry.header);
-      const body = "body" in entry ? entry.body : entry.data;
-      if (!body) {
-        await entryStream.close();
-        continue;
-      }
-      if (body instanceof ReadableStream)
-        await body.pipeTo(entryStream);
-      else if (body instanceof Blob)
-        await body.stream().pipeTo(entryStream);
-      else
-        try {
-          const chunk = await normalizeBody(body);
-          if (chunk.length > 0) {
-            const writer = entryStream.getWriter();
-            await writer.write(chunk);
-            await writer.close();
-          } else
-            await entryStream.close();
-        } catch {
-          throw new TypeError(`Unsupported content type for entry "${entry.header.name}".`);
-        }
-    }
-  })().then(() => controller.finalize()).catch((err) => controller.error(err));
-  return new Uint8Array(await streamToBuffer(readable));
-}
-
-class RXAImpl {
-  _buffer;
-  constructor(buffer) {
-    this._buffer = buffer;
-  }
-  get stream() {
-    const buffer = this._buffer;
-    return new ReadableStream({
-      start(controller) {
-        controller.enqueue(new Uint8Array(buffer));
-        controller.close();
-      }
-    });
-  }
-  async buffer() {
-    return this._buffer;
-  }
-}
-async function archive(files) {
-  const entries = Object.entries(files).map(([name, content]) => {
-    return {
-      header: { name, size: content.length, type: "file" },
-      body: new Uint8Array(content)
-    };
-  });
-  const tarBuffer = await packTar(entries);
-  const gzipBuffer = await gzipAsync(Buffer.from(tarBuffer));
-  return new RXAImpl(gzipBuffer);
-}
 function $constructor(name, initializer, params) {
   function init2(inst, def) {
     if (!inst._zod) {
@@ -4829,121 +4479,6 @@ function bigint3(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 locate(rxm) {
-  return {
-    registry: rxm.definition.registry,
-    path: rxm.definition.path,
-    name: rxm.definition.name,
-    tag: rxm.definition.tag
-  };
-}
-function manifest(rxd) {
-  return {
-    definition: {
-      name: rxd.name,
-      type: rxd.type,
-      tag: rxd.tag ?? "latest",
-      registry: rxd.registry,
-      path: rxd.path,
-      description: rxd.description,
-      author: rxd.author,
-      license: rxd.license,
-      keywords: rxd.keywords,
-      repository: rxd.repository
-    },
-    archive: {},
-    source: {}
-  };
-}
-function resource(rxm, rxa) {
-  const rxi = locate(rxm);
-  return {
-    identifier: rxi,
-    manifest: rxm,
-    archive: rxa
-  };
-}
-
-class FolderLoader {
-  async canLoad(source) {
-    try {
-      const stats = await stat(source);
-      if (!stats.isDirectory()) {
-        return false;
-      }
-      const manifestPath = join(source, "resource.json");
-      const manifestStats = await stat(manifestPath);
-      return manifestStats.isFile();
-    } catch {
-      return false;
-    }
-  }
-  async load(folderPath) {
-    const resourceJsonPath = join(folderPath, "resource.json");
-    let resourceJson;
-    try {
-      resourceJson = await readFile(resourceJsonPath, "utf-8");
-    } catch (error48) {
-      throw new ResourceXError(`Failed to read resource.json: ${error48 instanceof Error ? error48.message : String(error48)}`);
-    }
-    let json2;
-    try {
-      json2 = JSON.parse(resourceJson);
-    } catch (error48) {
-      throw new ResourceXError(`Invalid JSON in resource.json: ${error48 instanceof Error ? error48.message : String(error48)}`);
-    }
-    const rxd = define(json2);
-    const files = await this.readFolderFiles(folderPath);
-    if (Object.keys(files).length === 0) {
-      throw new ResourceXError("No content files found in resource folder");
-    }
-    const rxm = manifest(rxd);
-    const rxa = await archive(files);
-    return resource(rxm, rxa);
-  }
-  async readFolderFiles(folderPath, basePath = folderPath) {
-    const files = {};
-    const entries = await readdir(folderPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(folderPath, entry.name);
-      const relativePath = relative(basePath, fullPath);
-      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) {
@@ -4962,31 +4497,6 @@ class FolderSourceLoader {
     const files = await this.readFolderFiles(source);
     return { source, files };
   }
-  async isFresh(source, cachedAt) {
-    try {
-      const maxMtime = await this.getMaxMtime(source);
-      return maxMtime <= cachedAt;
-    } catch {
-      return false;
-    }
-  }
-  async getMaxMtime(folderPath) {
-    let max = new Date(0);
-    const entries = await readdir2(folderPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join2(folderPath, entry.name);
-      if (entry.isFile()) {
-        const stats = await stat2(fullPath);
-        if (stats.mtime > max)
-          max = stats.mtime;
-      } else if (entry.isDirectory()) {
-        const subMax = await this.getMaxMtime(fullPath);
-        if (subMax > max)
-          max = subMax;
-      }
-    }
-    return max;
-  }
   async readFolderFiles(folderPath, basePath = folderPath) {
     const files = {};
     const entries = await readdir2(folderPath, { withFileTypes: true });
@@ -5187,7 +4697,7 @@ var __defProp2, __export2 = (target, all) => {
       configurable: true,
       set: (newValue) => all[name] = () => newValue
     });
-}, 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) => {
+}, BLOCK_SIZE = 512, ZERO_BLOCK, EMPTY, encoder, decoder, EOF_BUFFER, gzipAsync, exports_external, exports_core2, NEVER, $brand, $ZodAsyncError, $ZodEncodeError, globalConfig, exports_util, EVALUATING, captureStackTrace, allowsEval, getParsedType = (data) => {
   const t2 = typeof data;
   switch (t2) {
     case "undefined":
@@ -10865,22 +10375,9 @@ var __defProp2, __export2 = (target, all) => {
   Codec: ZodCodec,
   Boolean: ZodBoolean,
   String: ZodString
-}, ...args), ZodIssueCode, ZodFirstPartyTypeKind, z2, RECOGNIZED_KEYS, exports_coerce, ResourceXError, DefinitionError, RXDSchema, gunzipAsync, RegistryError, textType, jsonType, binaryType, skillType, builtinTypes, ResourceTypeError;
+}, ...args), ZodIssueCode, ZodFirstPartyTypeKind, z2, RECOGNIZED_KEYS, exports_coerce, ResourceXError, RXDSchema, gunzipAsync, RegistryError, textType, jsonType, binaryType, skillType, prototypeType, builtinTypes, ResourceTypeError;
 var init_dist = __esm(() => {
   __defProp2 = Object.defineProperty;
-  TYPEFLAG = {
-    file: "0",
-    link: "1",
-    symlink: "2",
-    "character-device": "3",
-    "block-device": "4",
-    directory: "5",
-    fifo: "6",
-    "pax-header": "x",
-    "pax-global-header": "g",
-    "gnu-long-name": "L",
-    "gnu-long-link-name": "K"
-  };
   ZERO_BLOCK = new Uint8Array(BLOCK_SIZE);
   EMPTY = new Uint8Array(0);
   encoder = new TextEncoder;
@@ -14854,17 +14351,10 @@ var init_dist = __esm(() => {
       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),
     tag: exports_external.string().max(64).optional(),
-    version: exports_external.string().max(64).optional(),
     registry: exports_external.string().max(256).optional(),
     path: exports_external.string().max(256).optional(),
     description: exports_external.string().max(1024).optional(),
@@ -14966,7 +14456,47 @@ var skill_type_default = {
       }
     }
   };
-  builtinTypes = [textType, jsonType, binaryType, skillType];
+  prototypeType = {
+    name: "prototype",
+    description: "Instruction set for materializing roles and organizations",
+    code: `// @resolver: prototype_type_default
+var prototype_type_default = {
+  async resolve(ctx) {
+    var protoFile = ctx.files["prototype.json"];
+    if (!protoFile) throw new Error("Prototype resource must contain a prototype.json file");
+    var decoder = new TextDecoder();
+    var instructions = JSON.parse(decoder.decode(protoFile));
+    if (!Array.isArray(instructions)) {
+      throw new Error("prototype.json must be a JSON array of instructions");
+    }
+    var resolved = instructions.map(function(instr) {
+      var resolvedArgs = {};
+      var keys = Object.keys(instr.args || {});
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        var value = instr.args[key];
+        if (typeof value === "string" && value.startsWith("@")) {
+          var filename = value.slice(1);
+          var file = ctx.files[filename];
+          if (!file) throw new Error("Referenced file not found: " + filename);
+          resolvedArgs[key] = decoder.decode(file);
+        } else {
+          resolvedArgs[key] = value;
+        }
+      }
+      return { op: instr.op, args: resolvedArgs };
+    });
+    return { id: ctx.manifest.name, instructions: resolved };
+  }
+};`
+  };
+  builtinTypes = [
+    textType,
+    jsonType,
+    binaryType,
+    skillType,
+    prototypeType
+  ];
   ResourceTypeError = class ResourceTypeError extends ResourceXError {
     constructor(message) {
       super(message);
@@ -14984,13 +14514,13 @@ __export(exports_dist, {
 });
 import { createHash as createHash2 } from "crypto";
 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 { mkdir, readdir, stat, unlink, writeFile } from "fs/promises";
+import { join } from "path";
+import { mkdir as mkdir2, readdir as readdir22, readFile, rm, stat as stat22, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 import { join as join22 } from "path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { dirname, join as join32 } from "path";
+import { dirname, join as join3 } from "path";
 
 class FileSystemRXAStore {
   basePath;
@@ -14999,7 +14529,7 @@ class FileSystemRXAStore {
   }
   getPath(digest) {
     const prefix = digest.substring(7, 9);
-    return join3(this.basePath, prefix, digest);
+    return join(this.basePath, prefix, digest);
   }
   async get(digest) {
     if (!isValidDigest(digest)) {
@@ -15031,7 +14561,7 @@ class FileSystemRXAStore {
     if (await this.has(digest)) {
       return digest;
     }
-    const dir = join3(path, "..");
+    const dir = join(path, "..");
     await mkdir(dir, { recursive: true });
     await writeFile(path, data);
     return digest;
@@ -15039,7 +14569,7 @@ class FileSystemRXAStore {
   async has(digest) {
     const path = this.getPath(digest);
     try {
-      await stat3(path);
+      await stat(path);
       return true;
     } catch {
       return false;
@@ -15054,11 +14584,11 @@ class FileSystemRXAStore {
   async list() {
     const digests = [];
     try {
-      const prefixes = await readdir3(this.basePath);
+      const prefixes = await readdir(this.basePath);
       for (const prefix of prefixes) {
-        const prefixPath = join3(this.basePath, prefix);
+        const prefixPath = join(this.basePath, prefix);
         try {
-          const files = await readdir3(prefixPath);
+          const files = await readdir(prefixPath);
           for (const file2 of files) {
             if (file2.startsWith("sha256:")) {
               digests.push(file2);
@@ -15086,17 +14616,17 @@ class FileSystemRXMStore {
   async get(name, tag, registry2) {
     const path = this.getPath(name, tag, registry2);
     try {
-      const data = await readFile3(path, "utf-8");
+      const data = await readFile(path, "utf-8");
       return JSON.parse(data);
     } catch {
       return null;
     }
   }
-  async put(manifest2) {
-    const path = this.getPath(manifest2.name, manifest2.tag, manifest2.registry);
+  async put(manifest) {
+    const path = this.getPath(manifest.name, manifest.tag, manifest.registry);
     const dir = join22(path, "..");
     await mkdir2(dir, { recursive: true });
-    await writeFile2(path, JSON.stringify(manifest2, null, 2), "utf-8");
+    await writeFile2(path, JSON.stringify(manifest, null, 2), "utf-8");
   }
   async has(name, tag, registry2) {
     const path = this.getPath(name, tag, registry2);
@@ -15134,7 +14664,7 @@ class FileSystemRXMStore {
   async getLatest(name, registry2) {
     const dir = this.getDir(name, registry2);
     try {
-      return (await readFile3(join22(dir, LATEST_FILE), "utf-8")).trim();
+      return (await readFile(join22(dir, LATEST_FILE), "utf-8")).trim();
     } catch {
       return null;
     }
@@ -15188,9 +14718,9 @@ class FileSystemRXMStore {
             for (const file2 of files) {
               if (file2.endsWith(".json")) {
                 const filePath = join22(namePath, file2);
-                const data = await readFile3(filePath, "utf-8");
-                const manifest2 = JSON.parse(data);
-                results.push(manifest2);
+                const data = await readFile(filePath, "utf-8");
+                const manifest = JSON.parse(data);
+                results.push(manifest);
               }
             }
           } catch {}
@@ -15216,13 +14746,10 @@ class NodeProvider {
   createStores(config2) {
     const basePath = config2.path ?? DEFAULT_BASE_PATH;
     return {
-      rxaStore: new FileSystemRXAStore(join32(basePath, "blobs")),
-      rxmStore: new FileSystemRXMStore(join32(basePath, "manifests"))
+      rxaStore: new FileSystemRXAStore(join3(basePath, "blobs")),
+      rxmStore: new FileSystemRXMStore(join3(basePath, "manifests"))
     };
   }
-  createLoader(_config) {
-    return new FolderLoader;
-  }
   createSourceLoader(_config) {
     return new FolderSourceLoader;
   }
@@ -15232,7 +14759,7 @@ class NodeProvider {
       return { registry: envRegistry };
     }
     const basePath = config2.path ?? DEFAULT_BASE_PATH;
-    const configPath = join32(basePath, "config.json");
+    const configPath = join3(basePath, "config.json");
     try {
       if (existsSync(configPath)) {
         const raw = JSON.parse(readFileSync(configPath, "utf-8"));
@@ -15249,7 +14776,7 @@ class NodeProvider {
   }
   configPath(config2) {
     const basePath = config2.path ?? DEFAULT_BASE_PATH;
-    return join32(basePath, "config.json");
+    return join3(basePath, "config.json");
   }
   readConfig(config2) {
     const configPath = this.configPath(config2);
@@ -17252,14 +16779,14 @@ import { createResourceX, setProvider } from "resourcexjs";
 
 // src/lib/paths.ts
 import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
-var RX_HOME = process.env.RESOURCEX_HOME || process.env.RX_HOME || join5(homedir2(), ".deepractice", "resourcex");
+import { join as join4 } from "path";
+var RX_HOME = process.env.RESOURCEX_HOME || process.env.RX_HOME || join4(homedir2(), ".deepractice", "resourcex");
 var PATHS = {
   root: RX_HOME,
-  config: join5(RX_HOME, "config.json"),
-  local: join5(RX_HOME, "local"),
-  cache: join5(RX_HOME, "cache"),
-  linked: join5(RX_HOME, "linked")
+  config: join4(RX_HOME, "config.json"),
+  local: join4(RX_HOME, "local"),
+  cache: join4(RX_HOME, "cache"),
+  linked: join4(RX_HOME, "linked")
 };
 
 // src/lib/config.ts
@@ -17389,13 +16916,13 @@ var add = defineCommand({
   async run({ args }) {
     try {
       const rx = await getClient();
-      const resource2 = await rx.add(args.path);
+      const resource = await rx.add(args.path);
       consola.success(`Added resource:
 `);
-      console.log(`  Locator:  ${resource2.locator}`);
-      console.log(`  Name:     ${resource2.definition.name}`);
-      console.log(`  Type:     ${resource2.definition.type}`);
-      console.log(`  Tag:      ${resource2.definition.tag}`);
+      console.log(`  Locator:  ${resource.locator}`);
+      console.log(`  Name:     ${resource.definition.name}`);
+      console.log(`  Type:     ${resource.definition.type}`);
+      console.log(`  Tag:      ${resource.definition.tag}`);
     } catch (error48) {
       consola.error(error48 instanceof Error ? error48.message : "Failed to add resource");
       process.exit(1);
@@ -17509,13 +17036,13 @@ var info = defineCommand({
   async run({ args }) {
     try {
       const rx = await getClient();
-      const resource2 = await rx.info(args.locator);
-      const { definition, source } = resource2;
+      const resource = await rx.info(args.locator);
+      const { definition, source } = resource;
       console.log();
       console.log(`  ${definition.name}:${definition.tag}`);
       console.log(`  ${"\u2500".repeat(40)}`);
       console.log();
-      console.log(`  Locator:  ${resource2.locator}`);
+      console.log(`  Locator:  ${resource.locator}`);
       if (definition.registry) {
         console.log(`  Registry: ${definition.registry}`);
       }
@@ -17988,4 +17515,4 @@ var main = defineCommand({
 });
 runMain(main);
 
-//# debugId=2856F8DBC43B5B9B64756E2164756E21
+//# debugId=AA7C8D804CBA334B64756E2164756E21