@resourcexjs/cli 2.5.4 → 2.5.6

package/dist/index.js

@@ -769,9 +769,975 @@ var init_prompt = __esm(() => {
   kCancel = Symbol.for("cancel");
 });
 
-// ../../node_modules/.bun/@hono+node-server@1.19.9+115df24086ffac64/node_modules/@hono/node-server/dist/index.mjs
+// ../../packages/core/dist/index.js
+import { gzip } from "zlib";
+import { promisify } from "util";
+import { gunzip } from "zlib";
+import { promisify as promisify2 } from "util";
+import { join, relative } from "path";
+import { stat, readFile as readFile2, readdir } from "fs/promises";
+import { createHash } from "crypto";
+function define(input) {
+  if (input === null || typeof input !== "object") {
+    throw new DefinitionError("definition must be an object");
+  }
+  const obj = input;
+  if (!obj.name || typeof obj.name !== "string") {
+    throw new DefinitionError("name is required");
+  }
+  if (!obj.type || typeof obj.type !== "string") {
+    throw new DefinitionError("type is required");
+  }
+  const tagValue = obj.tag ?? obj.version;
+  if (tagValue !== undefined && typeof tagValue !== "string") {
+    throw new DefinitionError("tag must be a string");
+  }
+  const rxd = {
+    ...obj,
+    name: obj.name,
+    type: obj.type,
+    tag: typeof tagValue === "string" ? tagValue : undefined,
+    registry: typeof obj.registry === "string" ? obj.registry : undefined,
+    path: typeof obj.path === "string" ? obj.path : undefined,
+    description: typeof obj.description === "string" ? obj.description : undefined,
+    author: typeof obj.author === "string" ? obj.author : undefined,
+    license: typeof obj.license === "string" ? obj.license : undefined,
+    keywords: Array.isArray(obj.keywords) ? obj.keywords : undefined,
+    repository: typeof obj.repository === "string" ? obj.repository : undefined
+  };
+  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 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 locate(rxm) {
+  return {
+    registry: rxm.registry,
+    path: rxm.path,
+    name: rxm.name,
+    tag: rxm.tag
+  };
+}
+function resource(rxm, rxa) {
+  const rxl = locate(rxm);
+  return {
+    locator: rxl,
+    manifest: rxm,
+    archive: 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 {
+      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 readFile2(resourceJsonPath, "utf-8");
+    } catch (error) {
+      throw new ResourceXError(`Failed to read resource.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let json;
+    try {
+      json = JSON.parse(resourceJson);
+    } catch (error) {
+      throw new ResourceXError(`Invalid JSON in resource.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const rxd = define(json);
+    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 readFile2(fullPath);
+      } else if (entry.isDirectory()) {
+        const subFiles = await this.readFolderFiles(fullPath, basePath);
+        Object.assign(files, subFiles);
+      }
+    }
+    return files;
+  }
+}
+function computeDigest(data) {
+  const hash = createHash("sha256").update(data).digest("hex");
+  return `sha256:${hash}`;
+}
+
+class MemoryRXAStore {
+  blobs = new Map;
+  async get(digest) {
+    const blob = this.blobs.get(digest);
+    if (!blob) {
+      throw new RegistryError(`Blob not found: ${digest}`);
+    }
+    return blob;
+  }
+  async put(data) {
+    const digest = computeDigest(data);
+    if (!this.blobs.has(digest)) {
+      this.blobs.set(digest, data);
+    }
+    return digest;
+  }
+  async has(digest) {
+    return this.blobs.has(digest);
+  }
+  async delete(digest) {
+    this.blobs.delete(digest);
+  }
+  async list() {
+    return Array.from(this.blobs.keys());
+  }
+  clear() {
+    this.blobs.clear();
+  }
+}
+
+class MemoryRXMStore {
+  manifests = new Map;
+  buildKey(name, tag, registry) {
+    return registry ? `${registry}/${name}:${tag}` : `${name}:${tag}`;
+  }
+  async get(name, tag, registry) {
+    const key = this.buildKey(name, tag, registry);
+    return this.manifests.get(key) ?? null;
+  }
+  async put(manifest2) {
+    const key = this.buildKey(manifest2.name, manifest2.tag, manifest2.registry);
+    this.manifests.set(key, {
+      ...manifest2,
+      updatedAt: new Date
+    });
+  }
+  async has(name, tag, registry) {
+    const key = this.buildKey(name, tag, registry);
+    return this.manifests.has(key);
+  }
+  async delete(name, tag, registry) {
+    const key = this.buildKey(name, tag, registry);
+    this.manifests.delete(key);
+  }
+  async listTags(name, registry) {
+    const tags = [];
+    for (const m2 of this.manifests.values()) {
+      if (m2.name === name && m2.registry === registry) {
+        tags.push(m2.tag);
+      }
+    }
+    return tags;
+  }
+  async listNames(registry, query) {
+    const names = new Set;
+    for (const m2 of this.manifests.values()) {
+      if (registry !== undefined && m2.registry !== registry)
+        continue;
+      if (query && !m2.name.toLowerCase().includes(query.toLowerCase()))
+        continue;
+      names.add(m2.name);
+    }
+    return Array.from(names);
+  }
+  async search(options) {
+    const { registry, query, limit, offset = 0 } = options ?? {};
+    let results = Array.from(this.manifests.values());
+    if (registry !== undefined) {
+      if (registry === null) {
+        results = results.filter((m2) => !m2.registry);
+      } else {
+        results = results.filter((m2) => m2.registry === registry);
+      }
+    }
+    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(registry) {
+    for (const [key, m2] of this.manifests.entries()) {
+      if (m2.registry === registry) {
+        this.manifests.delete(key);
+      }
+    }
+  }
+  clear() {
+    this.manifests.clear();
+  }
+}
+var ResourceXError, DefinitionError, 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, builtinTypes, RegistryError;
+var init_dist = __esm(() => {
+  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);
+  gunzipAsync = promisify2(gunzip);
+  ResourceTypeError = class ResourceTypeError extends ResourceXError {
+    constructor(message) {
+      super(message);
+      this.name = "ResourceTypeError";
+    }
+  };
+  textType = {
+    name: "text",
+    aliases: ["txt", "plaintext"],
+    description: "Plain text content",
+    code: `// @resolver: text_type_default
+// src/builtins/text.type.ts
+var text_type_default = {
+  name: "text",
+  aliases: ["txt", "plaintext"],
+  description: "Plain text content",
+  async resolve(ctx) {
+    const content = ctx.files["content"];
+    return new TextDecoder().decode(content);
+  }
+};`
+  };
+  jsonType = {
+    name: "json",
+    aliases: ["config", "manifest"],
+    description: "JSON content",
+    code: `// @resolver: json_type_default
+// src/builtins/json.type.ts
+var json_type_default = {
+  name: "json",
+  aliases: ["config", "manifest"],
+  description: "JSON content",
+  async resolve(ctx) {
+    const content = ctx.files["content"];
+    return JSON.parse(new TextDecoder().decode(content));
+  }
+};`
+  };
+  binaryType = {
+    name: "binary",
+    aliases: ["bin", "blob", "raw"],
+    description: "Binary content",
+    code: `// @resolver: binary_type_default
+// src/builtins/binary.type.ts
+var binary_type_default = {
+  name: "binary",
+  aliases: ["bin", "blob", "raw"],
+  description: "Binary content",
+  async resolve(ctx) {
+    return ctx.files["content"];
+  }
+};`
+  };
+  builtinTypes = [textType, jsonType, binaryType];
+  RegistryError = class RegistryError extends ResourceXError {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "RegistryError";
+    }
+  };
+});
+
+// ../../packages/node-provider/dist/index.js
 var exports_dist = {};
 __export(exports_dist, {
+  NodeProvider: () => NodeProvider,
+  FileSystemRXMStore: () => FileSystemRXMStore,
+  FileSystemRXAStore: () => FileSystemRXAStore
+});
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { mkdir, readFile, writeFile, unlink, readdir as readdir2, stat as stat2 } from "fs/promises";
+import { join as join2 } from "path";
+import { mkdir as mkdir2, readFile as readFile22, writeFile as writeFile2, unlink as unlink2, readdir as readdir22, stat as stat22, rm } from "fs/promises";
+import { join as join22 } from "path";
+
+class FileSystemRXAStore {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  getPath(digest) {
+    const prefix = digest.substring(7, 9);
+    return join2(this.basePath, prefix, digest);
+  }
+  async get(digest) {
+    const path = this.getPath(digest);
+    try {
+      return await readFile(path);
+    } catch (error) {
+      throw new RegistryError(`Blob not found: ${digest}`);
+    }
+  }
+  async put(data) {
+    const digest = computeDigest(data);
+    const path = this.getPath(digest);
+    if (await this.has(digest)) {
+      return digest;
+    }
+    const dir = join2(path, "..");
+    await mkdir(dir, { recursive: true });
+    await writeFile(path, data);
+    return digest;
+  }
+  async has(digest) {
+    const path = this.getPath(digest);
+    try {
+      await stat2(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(digest) {
+    const path = this.getPath(digest);
+    try {
+      await unlink(path);
+    } catch {}
+  }
+  async list() {
+    const digests = [];
+    try {
+      const prefixes = await readdir2(this.basePath);
+      for (const prefix of prefixes) {
+        const prefixPath = join2(this.basePath, prefix);
+        try {
+          const files = await readdir2(prefixPath);
+          for (const file of files) {
+            if (file.startsWith("sha256:")) {
+              digests.push(file);
+            }
+          }
+        } catch {}
+      }
+    } catch {}
+    return digests;
+  }
+}
+
+class FileSystemRXMStore {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  getDir(name, registry) {
+    const registryDir = registry ?? LOCAL_DIR;
+    return join22(this.basePath, registryDir, name);
+  }
+  getPath(name, tag, registry) {
+    return join22(this.getDir(name, registry), `${tag}.json`);
+  }
+  async get(name, tag, registry) {
+    const path = this.getPath(name, tag, registry);
+    try {
+      const data = await readFile22(path, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async put(manifest2) {
+    const path = this.getPath(manifest2.name, manifest2.tag, manifest2.registry);
+    const dir = join22(path, "..");
+    await mkdir2(dir, { recursive: true });
+    await writeFile2(path, JSON.stringify(manifest2, null, 2), "utf-8");
+  }
+  async has(name, tag, registry) {
+    const path = this.getPath(name, tag, registry);
+    try {
+      await stat22(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(name, tag, registry) {
+    const path = this.getPath(name, tag, registry);
+    try {
+      await unlink2(path);
+    } catch {}
+  }
+  async listTags(name, registry) {
+    const dir = this.getDir(name, registry);
+    const tags = [];
+    try {
+      const files = await readdir22(dir);
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          tags.push(file.replace(".json", ""));
+        }
+      }
+    } catch {}
+    return tags;
+  }
+  async listNames(registry, query) {
+    const registryDir = registry ?? LOCAL_DIR;
+    const basePath = join22(this.basePath, registryDir);
+    const names = [];
+    try {
+      const entries = await readdir22(basePath);
+      for (const entry of entries) {
+        const entryPath = join22(basePath, entry);
+        try {
+          const entryStat = await stat22(entryPath);
+          if (entryStat.isDirectory()) {
+            if (!query || entry.toLowerCase().includes(query.toLowerCase())) {
+              names.push(entry);
+            }
+          }
+        } catch {}
+      }
+    } catch {}
+    return names;
+  }
+  async search(options) {
+    const { registry, query, limit, offset = 0 } = options ?? {};
+    const results = [];
+    let registryDirs = [];
+    if (registry === null) {
+      registryDirs = [LOCAL_DIR];
+    } else if (registry !== undefined) {
+      registryDirs = [registry];
+    } else {
+      try {
+        registryDirs = await readdir22(this.basePath);
+      } catch {
+        return [];
+      }
+    }
+    for (const regDir of registryDirs) {
+      const regPath = join22(this.basePath, regDir);
+      try {
+        const names = await readdir22(regPath);
+        for (const name of names) {
+          if (query && !name.toLowerCase().includes(query.toLowerCase())) {
+            continue;
+          }
+          const namePath = join22(regPath, name);
+          try {
+            const files = await readdir22(namePath);
+            for (const file of files) {
+              if (file.endsWith(".json")) {
+                const filePath = join22(namePath, file);
+                const data = await readFile22(filePath, "utf-8");
+                const manifest2 = JSON.parse(data);
+                results.push(manifest2);
+              }
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+    let paginated = results.slice(offset);
+    if (limit !== undefined) {
+      paginated = paginated.slice(0, limit);
+    }
+    return paginated;
+  }
+  async deleteByRegistry(registry) {
+    const regPath = join22(this.basePath, registry);
+    try {
+      await rm(regPath, { recursive: true });
+    } catch {}
+  }
+}
+
+class NodeProvider {
+  platform = "node";
+  createStores(config) {
+    const basePath = config.path ?? DEFAULT_BASE_PATH;
+    return {
+      rxaStore: new FileSystemRXAStore(join3(basePath, "blobs")),
+      rxmStore: new FileSystemRXMStore(join3(basePath, "manifests"))
+    };
+  }
+  createLoader(_config) {
+    return new FolderLoader;
+  }
+}
+var LOCAL_DIR = "_local", DEFAULT_BASE_PATH;
+var init_dist2 = __esm(() => {
+  init_dist();
+  init_dist();
+  DEFAULT_BASE_PATH = `${homedir()}/.resourcex`;
+});
+
+// ../../node_modules/.bun/@hono+node-server@1.19.9+115df24086ffac64/node_modules/@hono/node-server/dist/index.mjs
+var exports_dist2 = {};
+__export(exports_dist2, {
   serve: () => serve,
   getRequestListener: () => getRequestListener,
   createAdaptorServer: () => createAdaptorServer,
@@ -1151,7 +2117,7 @@ var RequestError, toRequestError = (e2) => {
   });
   return server;
 };
-var init_dist = __esm(() => {
+var init_dist3 = __esm(() => {
   RequestError = class extends Error {
     constructor(message, options) {
       super(message, options);
@@ -2697,18 +3663,19 @@ async function runMain(cmd, opts = {}) {
 }
 
 // src/lib/client.ts
-import { createResourceX } from "resourcexjs";
+init_dist2();
+import { createResourceX, setProvider } from "resourcexjs";
 
 // src/lib/paths.ts
-import { homedir } from "os";
-import { join } from "path";
-var RX_HOME = process.env.RX_HOME || join(homedir(), ".resourcex");
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+var RX_HOME = process.env.RX_HOME || join4(homedir2(), ".resourcex");
 var PATHS = {
   root: RX_HOME,
-  config: join(RX_HOME, "config.json"),
-  local: join(RX_HOME, "local"),
-  cache: join(RX_HOME, "cache"),
-  linked: join(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
@@ -2735,6 +3702,7 @@ async function setConfig(key, value) {
 }
 
 // src/lib/client.ts
+setProvider(new NodeProvider);
 async function getClient(options) {
   const cfg = await getConfig();
   return createResourceX({
@@ -2759,15 +3727,15 @@ var add = defineCommand({
   async run({ args }) {
     try {
       const rx = await getClient();
-      const resource = await rx.add(args.path);
+      const resource2 = await rx.add(args.path);
       consola.success(`Added resource:
 `);
-      console.log(`  Locator:  ${resource.locator}`);
-      console.log(`  Name:     ${resource.name}`);
-      console.log(`  Type:     ${resource.type}`);
-      console.log(`  Tag:      ${resource.tag}`);
-      if (resource.files?.length) {
-        console.log(`  Files:    ${resource.files.join(", ")}`);
+      console.log(`  Locator:  ${resource2.locator}`);
+      console.log(`  Name:     ${resource2.name}`);
+      console.log(`  Type:     ${resource2.type}`);
+      console.log(`  Tag:      ${resource2.tag}`);
+      if (resource2.files?.length) {
+        console.log(`  Files:    ${resource2.files.join(", ")}`);
       }
     } catch (error) {
       consola.error(error instanceof Error ? error.message : "Failed to add resource");
@@ -2776,56 +3744,6 @@ var add = defineCommand({
   }
 });
 
-// src/commands/link.ts
-var link = defineCommand({
-  meta: {
-    name: "link",
-    description: "Link resource directory for development"
-  },
-  args: {
-    path: {
-      type: "positional",
-      description: "Path to resource directory",
-      required: true
-    }
-  },
-  async run({ args }) {
-    try {
-      const rx = await getClient();
-      await rx.link(args.path);
-      consola.success(`Linked: ${args.path}`);
-    } catch (error) {
-      consola.error(error instanceof Error ? error.message : "Failed to link resource");
-      process.exit(1);
-    }
-  }
-});
-
-// src/commands/unlink.ts
-var unlink = defineCommand({
-  meta: {
-    name: "unlink",
-    description: "Unlink development directory"
-  },
-  args: {
-    locator: {
-      type: "positional",
-      description: "Resource locator (e.g., hello:1.0.0)",
-      required: true
-    }
-  },
-  async run({ args }) {
-    try {
-      const rx = await getClient();
-      await rx.unlink(args.locator);
-      consola.success(`Unlinked: ${args.locator}`);
-    } catch (error) {
-      consola.error(error instanceof Error ? error.message : "Failed to unlink resource");
-      process.exit(1);
-    }
-  }
-});
-
 // src/commands/list.ts
 var list = defineCommand({
   meta: {
@@ -2875,25 +3793,25 @@ var info = defineCommand({
   async run({ args }) {
     try {
       const rx = await getClient();
-      const resource = await rx.info(args.locator);
+      const resource2 = await rx.info(args.locator);
       console.log();
-      console.log(`  ${resource.name}:${resource.tag}`);
+      console.log(`  ${resource2.name}:${resource2.tag}`);
       console.log(`  ${"\u2500".repeat(40)}`);
       console.log();
-      console.log(`  Locator:  ${resource.locator}`);
-      if (resource.registry) {
-        console.log(`  Registry: ${resource.registry}`);
+      console.log(`  Locator:  ${resource2.locator}`);
+      if (resource2.registry) {
+        console.log(`  Registry: ${resource2.registry}`);
       }
-      if (resource.path) {
-        console.log(`  Path:     ${resource.path}`);
+      if (resource2.path) {
+        console.log(`  Path:     ${resource2.path}`);
       }
-      console.log(`  Name:     ${resource.name}`);
-      console.log(`  Type:     ${resource.type}`);
-      console.log(`  Tag:      ${resource.tag}`);
+      console.log(`  Name:     ${resource2.name}`);
+      console.log(`  Type:     ${resource2.type}`);
+      console.log(`  Tag:      ${resource2.tag}`);
       console.log();
-      if (resource.files?.length) {
+      if (resource2.files?.length) {
         console.log(`  Files:`);
-        printFileTree(resource.files);
+        printFileTree(resource2.files);
       }
       console.log();
     } catch (error) {
@@ -3183,6 +4101,7 @@ var config = defineCommand({
 });
 
 // src/commands/server.ts
+import { join as join6 } from "path";
 var server = defineCommand({
   meta: {
     name: "server",
@@ -3203,8 +4122,12 @@ var server = defineCommand({
     const port = parseInt(args.port, 10);
     const storagePath = args.storage || "./data";
     const { createRegistryServer } = await import("@resourcexjs/server");
-    const { serve: serve2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
-    const app = createRegistryServer({ storagePath });
+    const { FileSystemRXAStore: FileSystemRXAStore2, FileSystemRXMStore: FileSystemRXMStore2 } = await Promise.resolve().then(() => (init_dist2(), exports_dist));
+    const { serve: serve2 } = await Promise.resolve().then(() => (init_dist3(), exports_dist2));
+    const app = createRegistryServer({
+      rxaStore: new FileSystemRXAStore2(join6(storagePath, "blobs")),
+      rxmStore: new FileSystemRXMStore2(join6(storagePath, "manifests"))
+    });
     consola.info(`Starting registry server...`);
     console.log();
     console.log(`  Port:     ${port}`);
@@ -3272,8 +4195,6 @@ var main = defineCommand({
   },
   subCommands: {
     add,
-    link,
-    unlink,
     list,
     info,
     remove,
@@ -3288,4 +4209,4 @@ var main = defineCommand({
 });
 runMain(main);
 
-//# debugId=425C78D84A4EC9F064756E2164756E21
+//# debugId=806B8847021BED7E64756E2164756E21