@resourcexjs/core 2.17.2 → 2.19.0

package/dist/index.js

@@ -13,10 +13,6 @@ var __export = (target, all) => {
     });
 };
 
-// src/model/archive.ts
-import { promisify } from "node:util";
-import { gzip } from "node:zlib";
-
 // ../../node_modules/.bun/modern-tar@0.7.3/node_modules/modern-tar/dist/unpacker-BpPBxY8N.js
 var BLOCK_SIZE = 512;
 var BLOCK_SIZE_MASK = 511;
@@ -995,7 +991,28 @@ async function unpackTar(archive, options = {}) {
 }
 
 // src/model/archive.ts
-var gzipAsync = promisify(gzip);
+async function gzipCompress(data) {
+  const cs = new CompressionStream("gzip");
+  const writer = cs.writable.getWriter();
+  writer.write(data);
+  writer.close();
+  const reader = cs.readable.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+  }
+  const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return Buffer.from(result);
+}
 
 class RXAImpl {
   _buffer;
@@ -1023,7 +1040,7 @@ async function archive(files) {
     };
   });
   const tarBuffer = await packTar(entries);
-  const gzipBuffer = await gzipAsync(Buffer.from(tarBuffer));
+  const gzipBuffer = await gzipCompress(new Uint8Array(tarBuffer));
   return new RXAImpl(gzipBuffer);
 }
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
@@ -1283,7 +1300,7 @@ __export(exports_core2, {
   safeDecode: () => safeDecode,
   registry: () => registry,
   regexes: () => exports_regexes,
-  process: () => process2,
+  process: () => process,
   prettifyError: () => prettifyError,
   parseAsync: () => parseAsync,
   parse: () => parse,
@@ -11747,7 +11764,7 @@ function initializeContext(params) {
     external: params?.external ?? undefined
   };
 }
-function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a2;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
@@ -11784,7 +11801,7 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process2(parent, ctx, params);
+      process(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -12060,14 +12077,14 @@ function isTransforming(_schema, _ctx) {
 }
 var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process2(schema, ctx);
+  process(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
 var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process2(schema, ctx);
+  process(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
@@ -12318,7 +12335,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
   if (typeof maximum === "number")
     json.maxItems = maximum;
   json.type = "array";
-  json.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
+  json.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
 };
 var objectProcessor = (schema, ctx, _json, params) => {
   const json = _json;
@@ -12327,7 +12344,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json.properties[key] = process2(shape[key], ctx, {
+    json.properties[key] = process(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -12350,7 +12367,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
     if (ctx.io === "output")
       json.additionalProperties = false;
   } else if (def.catchall) {
-    json.additionalProperties = process2(def.catchall, ctx, {
+    json.additionalProperties = process(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -12359,7 +12376,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
-  const options = def.options.map((x, i) => process2(x, ctx, {
+  const options = def.options.map((x, i) => process(x, ctx, {
     ...params,
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
@@ -12371,11 +12388,11 @@ var unionProcessor = (schema, ctx, json, params) => {
 };
 var intersectionProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  const a = process2(def.left, ctx, {
+  const a = process(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
   });
-  const b = process2(def.right, ctx, {
+  const b = process(def.right, ctx, {
     ...params,
     path: [...params.path, "allOf", 1]
   });
@@ -12392,11 +12409,11 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   json.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
+  const prefixItems = def.items.map((x, i) => process(x, ctx, {
     ...params,
     path: [...params.path, prefixPath, i]
   }));
-  const rest = def.rest ? process2(def.rest, ctx, {
+  const rest = def.rest ? process(def.rest, ctx, {
     ...params,
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
@@ -12436,7 +12453,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
-    const valueSchema = process2(def.valueType, ctx, {
+    const valueSchema = process(def.valueType, ctx, {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
@@ -12446,12 +12463,12 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json.propertyNames = process2(def.keyType, ctx, {
+      json.propertyNames = process(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json.additionalProperties = process2(def.valueType, ctx, {
+    json.additionalProperties = process(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -12466,7 +12483,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 };
 var nullableProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  const inner = process2(def.innerType, ctx, params);
+  const inner = process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -12477,20 +12494,20 @@ var nullableProcessor = (schema, ctx, json, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
@@ -12498,7 +12515,7 @@ var prefaultProcessor = (schema, ctx, json, params) => {
 };
 var catchProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   let catchValue;
@@ -12512,32 +12529,32 @@ var catchProcessor = (schema, ctx, json, params) => {
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-  process2(innerType, ctx, params);
+  process(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process2(def.innerType, ctx, params);
+  process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var lazyProcessor = (schema, ctx, _json, params) => {
   const innerType = schema._zod.innerType;
-  process2(innerType, ctx, params);
+  process(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
@@ -12589,7 +12606,7 @@ function toJSONSchema(input, params) {
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
       const [_, schema] = entry;
-      process2(schema, ctx2);
+      process(schema, ctx2);
     }
     const schemas = {};
     const external = {
@@ -12612,7 +12629,7 @@ function toJSONSchema(input, params) {
     return { schemas };
   }
   const ctx = initializeContext({ ...params, processors: allProcessors });
-  process2(input, ctx);
+  process(input, ctx);
   extractDefs(ctx, input);
   return finalize(ctx, input);
 }
@@ -12658,7 +12675,7 @@ class JSONSchemaGenerator {
     });
   }
   process(schema, _params = { path: [], schemaPath: [] }) {
-    return process2(schema, this.ctx, _params);
+    return process(schema, this.ctx, _params);
   }
   emit(schema, _params) {
     if (_params) {
@@ -14634,12 +14651,31 @@ function define(input) {
   return rxd;
 }
 // src/model/extract.ts
-import { promisify as promisify2 } from "node:util";
-import { gunzip } from "node:zlib";
-var gunzipAsync = promisify2(gunzip);
+async function gzipDecompress(data) {
+  const ds = new DecompressionStream("gzip");
+  const writer = ds.writable.getWriter();
+  writer.write(data);
+  writer.close();
+  const reader = ds.readable.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+  }
+  const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return Buffer.from(result);
+}
 async function extract(rxa) {
   const buffer = await rxa.buffer();
-  const tarBuffer = await gunzipAsync(buffer);
+  const tarBuffer = await gzipDecompress(new Uint8Array(buffer));
   const entries = await unpackTar(tarBuffer);
   const files = {};
   for (const entry of entries) {
@@ -14696,7 +14732,6 @@ function manifest(rxd) {
   };
 }
 // src/model/parse.ts
-import { normalize } from "node:path";
 var MAX_LOCATOR_LENGTH = 256;
 var DANGEROUS_PATTERNS = /[;|&$`\n\0\r]/;
 function validateLocatorSecurity(locator) {
@@ -14718,8 +14753,21 @@ function validateLocatorSecurity(locator) {
   if (namePathPart.includes("..")) {
     throw new LocatorError("Path traversal detected", locator);
   }
-  const pathNormalized = normalize(decoded);
-  if (pathNormalized.startsWith("..") || pathNormalized.includes("/..") || pathNormalized.includes("\\..") || pathNormalized.startsWith("/") || pathNormalized.startsWith("\\")) {
+  const segments = decoded.split("/");
+  const stack = [];
+  for (const seg of segments) {
+    if (seg === "..") {
+      if (stack.length > 0)
+        stack.pop();
+      else {
+        throw new LocatorError("Path traversal detected", locator);
+      }
+    } else if (seg !== "." && seg !== "") {
+      stack.push(seg);
+    }
+  }
+  const pathNormalized = stack.join("/");
+  if (pathNormalized.startsWith("/") || pathNormalized.startsWith("\\")) {
     throw new LocatorError("Path traversal detected", locator);
   }
   if (DANGEROUS_PATTERNS.test(decoded)) {
@@ -14864,15 +14912,13 @@ function generateDefinition(result) {
   return define(input);
 }
 // src/detector/PrototypeDetector.ts
-import { basename } from "node:path";
-
 class PrototypeDetector {
   name = "prototype";
   detect(files, source) {
     if (!files["prototype.json"]) {
       return null;
     }
-    const name = basename(source);
+    const name = source.split("/").pop() ?? source;
     return {
       type: "prototype",
       name,
@@ -14913,15 +14959,13 @@ class ResourceJsonDetector {
   }
 }
 // src/detector/SkillDetector.ts
-import { basename as basename2 } from "node:path";
-
 class SkillDetector {
   name = "skill";
   detect(files, source) {
     if (!files["SKILL.md"]) {
       return null;
     }
-    const name = basename2(source);
+    const name = source.split("/").pop() ?? source;
     const content = files["SKILL.md"].toString("utf-8");
     const description = this.extractDescription(content);
     return {
@@ -14966,101 +15010,6 @@ class TypeDetectorChain {
     throw new ResourceXError(`Cannot detect resource type from source: ${source}. ` + `No detector matched. ` + `Files: [${Object.keys(files).join(", ")}]`);
   }
 }
-// src/loader/FolderLoader.ts
-import { readdir, readFile, stat } from "node:fs/promises";
-import { join, relative } from "node:path";
-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;
-  }
-}
-// src/loader/FolderSourceLoader.ts
-import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { join as join2, relative as relative2 } from "node:path";
-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()) {
-        const subFiles = await this.readFolderFiles(fullPath, basePath);
-        Object.assign(files, subFiles);
-      }
-    }
-    return files;
-  }
-}
 // src/loader/GitHubSourceLoader.ts
 function parseGitHubUrl(url2) {
   const match = url2.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)$/);
@@ -15130,55 +15079,20 @@ class GitHubSourceLoader {
 }
 // src/loader/loadResource.ts
 async function loadResource(source, config2) {
-  const loader = config2?.loader ?? new FolderLoader;
+  const loader = config2.loader;
   const canLoad = await loader.canLoad(source);
   if (!canLoad) {
     throw new ResourceXError(`Cannot load resource from: ${source}`);
   }
   return loader.load(source);
 }
-// src/loader/NpmSourceLoader.ts
-import { dirname, join as join3 } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-var NPM_PREFIX = "npm:";
-
-class NpmSourceLoader {
-  folder = new FolderSourceLoader;
-  canLoad(source) {
-    return source.startsWith(NPM_PREFIX);
-  }
-  async load(source) {
-    if (!this.canLoad(source)) {
-      throw new ResourceXError(`Not an npm source: ${source}`);
-    }
-    const packageName = source.slice(NPM_PREFIX.length);
-    if (!packageName) {
-      throw new ResourceXError(`Empty package name in npm source: ${source}`);
-    }
-    const packageDir = this.resolvePackageDir(packageName);
-    const rxs = await this.folder.load(packageDir);
-    return { source, files: rxs.files };
-  }
-  resolvePackageDir(packageName) {
-    const entry = globalThis.Bun?.main ?? process.argv[1] ?? join3(process.cwd(), "noop.js");
-    const parent = pathToFileURL(entry).href;
-    try {
-      const url2 = import.meta.resolve(`${packageName}/package.json`, parent);
-      return dirname(fileURLToPath(url2));
-    } catch {
-      throw new ResourceXError(`Cannot resolve npm package: ${packageName}`);
-    }
-  }
-}
 // src/loader/SourceLoaderChain.ts
 class SourceLoaderChain {
   loaders = [];
   constructor() {}
   static create() {
     const chain = new SourceLoaderChain;
-    chain.loaders.push(new FolderSourceLoader);
     chain.loaders.push(new GitHubSourceLoader);
-    chain.loaders.push(new NpmSourceLoader);
     return chain;
   }
   register(loader) {
@@ -15314,16 +15228,17 @@ function withRegistryValidation(registry2, trustedRegistry) {
 var DomainValidation = RegistryValidation;
 var withDomainValidation = withRegistryValidation;
 // src/registry/store/digest.ts
-import { createHash } from "node:crypto";
-function computeDigest(data) {
-  const hash2 = createHash("sha256").update(data).digest("hex");
-  return `sha256:${hash2}`;
+async function computeDigest(data) {
+  const hash2 = await crypto.subtle.digest("SHA-256", data);
+  const hex3 = [...new Uint8Array(hash2)].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `sha256:${hex3}`;
 }
-function computeArchiveDigest(files) {
+async function computeArchiveDigest(files) {
   const entries = Object.keys(files).sort().map((name) => `${name}:${files[name]}`).join(`
 `);
-  const hash2 = createHash("sha256").update(entries).digest("hex");
-  return `sha256:${hash2}`;
+  const hash2 = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(entries));
+  const hex3 = [...new Uint8Array(hash2)].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `sha256:${hex3}`;
 }
 function isValidDigest(digest) {
   return /^sha256:[a-f0-9]{64}$/.test(digest);
@@ -15372,7 +15287,7 @@ class CASRegistry {
         repository: storedRxm.repository
       },
       archive: {
-        digest: storedRxm.digest ?? computeArchiveDigest(storedRxm.files)
+        digest: storedRxm.digest ?? await computeArchiveDigest(storedRxm.files)
       },
       source: {}
     };
@@ -15386,7 +15301,7 @@ class CASRegistry {
       const digest2 = await this.rxaStore.put(content);
       fileDigests[filename] = digest2;
     }
-    const digest = computeArchiveDigest(fileDigests);
+    const digest = await computeArchiveDigest(fileDigests);
     const storedRxm = {
       registry: rxr.manifest.definition.registry,
       path: rxr.manifest.definition.path,
@@ -15477,137 +15392,6 @@ class CASRegistry {
     return this.rxaStore.put(data);
   }
 }
-// src/registry/registries/LinkedRegistry.ts
-import { lstat, mkdir, readdir as readdir3, readlink, rm, symlink } from "node:fs/promises";
-import { join as join4, resolve as resolvePath } from "node:path";
-class LinkedRegistry {
-  basePath;
-  constructor(basePath) {
-    this.basePath = basePath;
-  }
-  buildLinkPath(rxi) {
-    const registry2 = rxi.registry ?? "localhost";
-    const tag = rxi.tag ?? "latest";
-    let linkPath = join4(this.basePath, registry2);
-    if (rxi.path) {
-      linkPath = join4(linkPath, rxi.path);
-    }
-    return join4(linkPath, rxi.name, tag);
-  }
-  async isSymlink(path) {
-    try {
-      const stats = await lstat(path);
-      return stats.isSymbolicLink();
-    } catch {
-      return false;
-    }
-  }
-  async get(rxi) {
-    const linkPath = this.buildLinkPath(rxi);
-    if (!await this.isSymlink(linkPath)) {
-      throw new RegistryError(`Linked resource not found: ${format(rxi)}`);
-    }
-    const targetPath = await readlink(linkPath);
-    return loadResource(targetPath);
-  }
-  async put(_rxr) {
-    throw new RegistryError("LinkedRegistry does not support put(). Use link() instead.");
-  }
-  async has(rxi) {
-    const linkPath = this.buildLinkPath(rxi);
-    return this.isSymlink(linkPath);
-  }
-  async remove(rxi) {
-    const linkPath = this.buildLinkPath(rxi);
-    if (await this.isSymlink(linkPath)) {
-      await rm(linkPath);
-    }
-  }
-  async list(options) {
-    const { query, limit, offset = 0 } = options ?? {};
-    const identifiers = [];
-    try {
-      await this.scanSymlinks(this.basePath, "", identifiers);
-    } catch {
-      return [];
-    }
-    let filtered = identifiers;
-    if (query) {
-      const lowerQuery = query.toLowerCase();
-      filtered = identifiers.filter((rxi) => {
-        const searchText = `${rxi.registry ?? ""} ${rxi.path ?? ""} ${rxi.name}`.toLowerCase();
-        return searchText.includes(lowerQuery);
-      });
-    }
-    let result = filtered.slice(offset);
-    if (limit !== undefined) {
-      result = result.slice(0, limit);
-    }
-    return result;
-  }
-  async link(devPath) {
-    const rxr = await loadResource(devPath);
-    const linkPath = this.buildLinkPath(rxr.identifier);
-    try {
-      const stats = await lstat(linkPath);
-      if (stats.isSymbolicLink() || stats.isDirectory()) {
-        await rm(linkPath, { recursive: true });
-      }
-    } catch {}
-    const parentPath = join4(linkPath, "..");
-    await mkdir(parentPath, { recursive: true });
-    const absolutePath = resolvePath(devPath);
-    await symlink(absolutePath, linkPath);
-    return rxr.identifier;
-  }
-  async unlink(rxi) {
-    return this.remove(rxi);
-  }
-  async scanSymlinks(dirPath, relativePath, identifiers) {
-    let entries;
-    try {
-      entries = await readdir3(dirPath);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = join4(dirPath, entry);
-      const relPath = relativePath ? `${relativePath}/${entry}` : entry;
-      try {
-        const stats = await lstat(fullPath);
-        if (stats.isSymbolicLink()) {
-          const rxi = this.parsePathToRXI(relPath);
-          if (rxi) {
-            identifiers.push(rxi);
-          }
-        } else if (stats.isDirectory()) {
-          await this.scanSymlinks(fullPath, relPath, identifiers);
-        }
-      } catch {}
-    }
-  }
-  parsePathToRXI(relPath) {
-    const parts = relPath.split("/");
-    if (parts.length < 3) {
-      return null;
-    }
-    const tag = parts.pop();
-    const name = parts.pop();
-    const registry2 = parts.shift();
-    const path = parts.length > 0 ? parts.join("/") : undefined;
-    let locatorStr = registry2;
-    if (path)
-      locatorStr += `/${path}`;
-    locatorStr += `/${name}`;
-    if (tag !== "latest")
-      locatorStr += `:${tag}`;
-    try {
-      return parse5(locatorStr);
-    } catch {
-      return null;
-    }
-  }
-}
 // src/registry/store/MemoryRXAStore.ts
 class MemoryRXAStore {
   blobs = new Map;
@@ -15619,7 +15403,7 @@ class MemoryRXAStore {
     return blob;
   }
   async put(data) {
-    const digest = computeDigest(data);
+    const digest = await computeDigest(data);
     if (!this.blobs.has(digest)) {
       this.blobs.set(digest, data);
     }
@@ -15852,44 +15636,6 @@ var builtinTypes = [
   skillType,
   prototypeType
 ];
-// src/type/bundler.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { isAbsolute, resolve } from "node:path";
-async function bundleResourceType(sourcePath, basePath) {
-  const fullPath = isAbsolute(sourcePath) ? sourcePath : resolve(basePath ?? process.cwd(), sourcePath);
-  const source = await readFile3(fullPath, "utf-8");
-  const result = await Bun.build({
-    stdin: {
-      contents: source,
-      resolveDir: resolve(fullPath, ".."),
-      loader: "ts"
-    },
-    target: "bun",
-    format: "esm",
-    minify: false
-  });
-  if (!result.success) {
-    const errors3 = result.logs.map((log) => log.message).join(`
-`);
-    throw new Error(`Failed to bundle ${sourcePath}: ${errors3}`);
-  }
-  const bundledCode = await result.outputs[0].text();
-  const tempModule = await import(fullPath);
-  const typeSource = tempModule.default;
-  if (!typeSource.name) {
-    throw new Error(`Resource type at ${sourcePath} must have a name`);
-  }
-  if (typeof typeSource.resolve !== "function") {
-    throw new Error(`Resource type at ${sourcePath} must have a resolve function`);
-  }
-  return {
-    name: typeSource.name,
-    aliases: typeSource.aliases,
-    description: typeSource.description ?? "",
-    schema: typeSource.schema,
-    code: bundledCode
-  };
-}
 // src/type/errors.ts
 class ResourceTypeError extends ResourceXError {
   constructor(message) {
@@ -15970,7 +15716,6 @@ export {
   discoverRegistry,
   define,
   computeDigest,
-  bundleResourceType,
   builtinTypes,
   binaryType,
   archive,
@@ -15988,14 +15733,11 @@ export {
   MemoryRXAStore,
   ManifestError,
   LocatorError,
-  LinkedRegistry,
   GitHubSourceLoader,
-  FolderSourceLoader,
-  FolderLoader,
   DomainValidation,
   DefinitionError,
   ContentError,
   CASRegistry
 };
 
-//# debugId=124BD7881166D2C664756E2164756E21
+//# debugId=72D5E1C3B1B1B3BE64756E2164756E21