@resourcexjs/type 2.3.0 → 2.4.0

package/dist/index.js

@@ -1,3 +1,41 @@
+// src/bundler.ts
+import { readFile } from "node:fs/promises";
+import { resolve, isAbsolute } from "node:path";
+async function bundleResourceType(sourcePath, basePath) {
+  const fullPath = isAbsolute(sourcePath) ? sourcePath : resolve(basePath ?? process.cwd(), sourcePath);
+  const source = await readFile(fullPath, "utf-8");
+  const result = await Bun.build({
+    stdin: {
+      contents: source,
+      resolveDir: resolve(fullPath, ".."),
+      loader: "ts"
+    },
+    target: "bun",
+    format: "esm",
+    minify: false
+  });
+  if (!result.success) {
+    const errors = result.logs.map((log) => log.message).join(`
+`);
+    throw new Error(`Failed to bundle ${sourcePath}: ${errors}`);
+  }
+  const bundledCode = await result.outputs[0].text();
+  const tempModule = await import(fullPath);
+  const typeSource = tempModule.default;
+  if (!typeSource.name) {
+    throw new Error(`Resource type at ${sourcePath} must have a name`);
+  }
+  if (typeof typeSource.resolve !== "function") {
+    throw new Error(`Resource type at ${sourcePath} must have a resolve function`);
+  }
+  return {
+    name: typeSource.name,
+    aliases: typeSource.aliases,
+    description: typeSource.description ?? "",
+    schema: typeSource.schema,
+    code: bundledCode
+  };
+}
 // ../core/dist/index.js
 import { gzip, gunzip } from "node:zlib";
 import { promisify } from "node:util";
@@ -8,1183 +46,15 @@ class ResourceXError extends Error {
     this.name = "ResourceXError";
   }
 }
-class ContentError extends ResourceXError {
-  constructor(message) {
-    super(message);
-    this.name = "ContentError";
-  }
-}
-
-class RXLImpl {
-  domain;
-  path;
-  name;
-  type;
-  version;
-  constructor(parts) {
-    this.domain = parts.domain;
-    this.path = parts.path;
-    this.name = parts.name;
-    this.type = parts.type;
-    this.version = parts.version;
-  }
-  toString() {
-    let result = "";
-    if (this.domain) {
-      result += this.domain + "/";
-      if (this.path) {
-        result += this.path + "/";
-      }
-    }
-    result += this.name;
-    if (this.type) {
-      result += "." + this.type;
-    }
-    if (this.version) {
-      result += "@" + this.version;
-    }
-    return result;
-  }
-}
-function isDomain(str) {
-  if (str === "localhost")
-    return true;
-  return str.includes(".");
-}
-function parseRXL(locator) {
-  let remaining = locator;
-  let version;
-  let type;
-  let domain;
-  let path;
-  let name;
-  const atIndex = remaining.indexOf("@");
-  if (atIndex !== -1) {
-    version = remaining.slice(atIndex + 1);
-    remaining = remaining.slice(0, atIndex);
-  }
-  const segments = remaining.split("/");
-  if (segments.length > 1 && isDomain(segments[0])) {
-    domain = segments[0];
-    const lastSegment = segments[segments.length - 1];
-    if (segments.length > 2) {
-      path = segments.slice(1, -1).join("/");
-    }
-    remaining = lastSegment;
-  } else {
-    remaining = segments.join("/");
-  }
-  const dotIndex = remaining.lastIndexOf(".");
-  if (dotIndex !== -1) {
-    type = remaining.slice(dotIndex + 1);
-    name = remaining.slice(0, dotIndex);
-  } else {
-    name = remaining;
-  }
-  return new RXLImpl({ domain, path, name, type, version });
-}
 var BLOCK_SIZE = 512;
-var BLOCK_SIZE_MASK = 511;
-var DEFAULT_FILE_MODE = 420;
-var DEFAULT_DIR_MODE = 493;
-var USTAR_NAME_OFFSET = 0;
-var USTAR_NAME_SIZE = 100;
-var USTAR_MODE_OFFSET = 100;
-var USTAR_MODE_SIZE = 8;
-var USTAR_UID_OFFSET = 108;
-var USTAR_UID_SIZE = 8;
-var USTAR_GID_OFFSET = 116;
-var USTAR_GID_SIZE = 8;
-var USTAR_SIZE_OFFSET = 124;
-var USTAR_SIZE_SIZE = 12;
-var USTAR_MTIME_OFFSET = 136;
-var USTAR_MTIME_SIZE = 12;
-var USTAR_CHECKSUM_OFFSET = 148;
-var USTAR_CHECKSUM_SIZE = 8;
-var USTAR_TYPEFLAG_OFFSET = 156;
-var USTAR_TYPEFLAG_SIZE = 1;
-var USTAR_LINKNAME_OFFSET = 157;
-var USTAR_LINKNAME_SIZE = 100;
-var USTAR_MAGIC_OFFSET = 257;
-var USTAR_MAGIC_SIZE = 6;
-var USTAR_VERSION_OFFSET = 263;
-var USTAR_VERSION_SIZE = 2;
-var USTAR_UNAME_OFFSET = 265;
-var USTAR_UNAME_SIZE = 32;
-var USTAR_GNAME_OFFSET = 297;
-var USTAR_GNAME_SIZE = 32;
-var USTAR_PREFIX_OFFSET = 345;
-var USTAR_PREFIX_SIZE = 155;
-var USTAR_VERSION = "00";
-var USTAR_MAX_UID_GID = 2097151;
-var USTAR_MAX_SIZE = 8589934591;
-var FILE = "file";
-var LINK = "link";
-var SYMLINK = "symlink";
-var DIRECTORY = "directory";
-var 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"
-};
-var FLAGTYPE = {
-  "0": FILE,
-  "1": LINK,
-  "2": SYMLINK,
-  "3": "character-device",
-  "4": "block-device",
-  "5": DIRECTORY,
-  "6": "fifo",
-  x: "pax-header",
-  g: "pax-global-header",
-  L: "gnu-long-name",
-  K: "gnu-long-link-name"
-};
 var ZERO_BLOCK = new Uint8Array(BLOCK_SIZE);
 var EMPTY = new Uint8Array(0);
 var encoder = new TextEncoder;
 var decoder = new TextDecoder;
-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));
-}
-function readString(view, offset, size) {
-  const end = view.indexOf(0, offset);
-  const sliceEnd = end === -1 || end > offset + size ? offset + size : end;
-  return decoder.decode(view.subarray(offset, sliceEnd));
-}
-function readOctal(view, offset, size) {
-  let value = 0;
-  const end = offset + size;
-  for (let i = offset;i < end; i++) {
-    const charCode = view[i];
-    if (charCode === 0)
-      break;
-    if (charCode === 32)
-      continue;
-    value = value * 8 + (charCode - 48);
-  }
-  return value;
-}
-function readNumeric(view, offset, size) {
-  if (view[offset] & 128) {
-    let result = 0;
-    result = view[offset] & 127;
-    for (let i = 1;i < size; i++)
-      result = result * 256 + view[offset + i];
-    if (!Number.isSafeInteger(result))
-      throw new Error("TAR number too large");
-    return result;
-  }
-  return readOctal(view, offset, size);
-}
-var isBodyless = (header) => header.type === DIRECTORY || header.type === SYMLINK || header.type === LINK;
-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 transformHeader(header, options) {
-  const { strip, filter, map } = options;
-  if (!strip && !filter && !map)
-    return header;
-  const h = { ...header };
-  if (strip && strip > 0) {
-    const components = h.name.split("/").filter(Boolean);
-    if (strip >= components.length)
-      return null;
-    const newName = components.slice(strip).join("/");
-    h.name = h.type === DIRECTORY && !newName.endsWith("/") ? `${newName}/` : newName;
-    if (h.linkname?.startsWith("/")) {
-      const linkComponents = h.linkname.split("/").filter(Boolean);
-      h.linkname = strip >= linkComponents.length ? "/" : `/${linkComponents.slice(strip).join("/")}`;
-    }
-  }
-  if (filter?.(h) === false)
-    return null;
-  const result = map ? map(h) : h;
-  if (result && (!result.name || !result.name.trim() || result.name === "." || result.name === "/"))
-    return null;
-  return result;
-}
-var CHECKSUM_SPACE = 32;
-var ASCII_ZERO = 48;
-function validateChecksum(block) {
-  const stored = readOctal(block, USTAR_CHECKSUM_OFFSET, USTAR_CHECKSUM_SIZE);
-  let sum = 0;
-  for (let i = 0;i < block.length; i++)
-    if (i >= USTAR_CHECKSUM_OFFSET && i < USTAR_CHECKSUM_OFFSET + USTAR_CHECKSUM_SIZE)
-      sum += CHECKSUM_SPACE;
-    else
-      sum += block[i];
-  return stored === sum;
-}
-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 i = USTAR_CHECKSUM_OFFSET + 6 - 1;i >= USTAR_CHECKSUM_OFFSET; i--) {
-    block[i] = (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 parseUstarHeader(block, strict) {
-  if (strict && !validateChecksum(block))
-    throw new Error("Invalid tar header checksum.");
-  const typeflag = readString(block, USTAR_TYPEFLAG_OFFSET, USTAR_TYPEFLAG_SIZE);
-  const header = {
-    name: readString(block, USTAR_NAME_OFFSET, USTAR_NAME_SIZE),
-    mode: readOctal(block, USTAR_MODE_OFFSET, USTAR_MODE_SIZE),
-    uid: readNumeric(block, USTAR_UID_OFFSET, USTAR_UID_SIZE),
-    gid: readNumeric(block, USTAR_GID_OFFSET, USTAR_GID_SIZE),
-    size: readNumeric(block, USTAR_SIZE_OFFSET, USTAR_SIZE_SIZE),
-    mtime: /* @__PURE__ */ new Date(readNumeric(block, USTAR_MTIME_OFFSET, USTAR_MTIME_SIZE) * 1000),
-    type: FLAGTYPE[typeflag] || FILE,
-    linkname: readString(block, USTAR_LINKNAME_OFFSET, USTAR_LINKNAME_SIZE)
-  };
-  const magic = readString(block, USTAR_MAGIC_OFFSET, USTAR_MAGIC_SIZE);
-  if (magic.trim() === "ustar") {
-    header.uname = readString(block, USTAR_UNAME_OFFSET, USTAR_UNAME_SIZE);
-    header.gname = readString(block, USTAR_GNAME_OFFSET, USTAR_GNAME_SIZE);
-  }
-  if (magic === "ustar")
-    header.prefix = readString(block, USTAR_PREFIX_OFFSET, USTAR_PREFIX_SIZE);
-  return header;
-}
-var PAX_MAPPING = {
-  path: ["name", (v) => v],
-  linkpath: ["linkname", (v) => v],
-  size: ["size", (v) => parseInt(v, 10)],
-  mtime: ["mtime", parseFloat],
-  uid: ["uid", (v) => parseInt(v, 10)],
-  gid: ["gid", (v) => parseInt(v, 10)],
-  uname: ["uname", (v) => v],
-  gname: ["gname", (v) => v]
-};
-function parsePax(buffer) {
-  const decoder$1 = new TextDecoder("utf-8");
-  const overrides = {};
-  const pax = {};
-  let offset = 0;
-  while (offset < buffer.length) {
-    const spaceIndex = buffer.indexOf(32, offset);
-    if (spaceIndex === -1)
-      break;
-    const length = parseInt(decoder$1.decode(buffer.subarray(offset, spaceIndex)), 10);
-    if (Number.isNaN(length) || length === 0)
-      break;
-    const recordEnd = offset + length;
-    const [key, value] = decoder$1.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1)).split("=", 2);
-    if (key && value !== undefined) {
-      pax[key] = value;
-      const mapping = PAX_MAPPING[key];
-      if (mapping) {
-        const [targetKey, parser] = mapping;
-        const parsedValue = parser(value);
-        if (typeof parsedValue === "string" || !Number.isNaN(parsedValue))
-          overrides[targetKey] = parsedValue;
-      }
-    }
-    offset = recordEnd;
-  }
-  if (Object.keys(pax).length > 0)
-    overrides.pax = pax;
-  return overrides;
-}
-function applyOverrides(header, overrides) {
-  if (overrides.name !== undefined)
-    header.name = overrides.name;
-  if (overrides.linkname !== undefined)
-    header.linkname = overrides.linkname;
-  if (overrides.size !== undefined)
-    header.size = overrides.size;
-  if (overrides.mtime !== undefined)
-    header.mtime = /* @__PURE__ */ new Date(overrides.mtime * 1000);
-  if (overrides.uid !== undefined)
-    header.uid = overrides.uid;
-  if (overrides.gid !== undefined)
-    header.gid = overrides.gid;
-  if (overrides.uname !== undefined)
-    header.uname = overrides.uname;
-  if (overrides.gname !== undefined)
-    header.gname = overrides.gname;
-  if (overrides.pax)
-    header.pax = Object.assign({}, header.pax ?? {}, overrides.pax);
-}
-function getMetaParser(type) {
-  switch (type) {
-    case "pax-global-header":
-    case "pax-header":
-      return parsePax;
-    case "gnu-long-name":
-      return (data) => ({ name: readString(data, 0, data.length) });
-    case "gnu-long-link-name":
-      return (data) => ({ linkname: readString(data, 0, data.length) });
-    default:
-      return;
-  }
-}
-function getHeaderBlocks(header) {
-  const base = createTarHeader(header);
-  const pax = generatePax(header);
-  if (!pax)
-    return [base];
-  const paxPadding = -pax.paxBody.length & BLOCK_SIZE_MASK;
-  const paddingBlocks = paxPadding > 0 ? [ZERO_BLOCK.subarray(0, paxPadding)] : [];
-  return [
-    pax.paxHeader,
-    pax.paxBody,
-    ...paddingBlocks,
-    base
-  ];
-}
 var EOF_BUFFER = new Uint8Array(BLOCK_SIZE * 2);
-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);
-      }
-    }
-  };
-}
-var INITIAL_CAPACITY = 256;
-function createChunkQueue() {
-  let chunks = new Array(INITIAL_CAPACITY);
-  let capacityMask = chunks.length - 1;
-  let head = 0;
-  let tail = 0;
-  let totalAvailable = 0;
-  const consumeFromHead = (count) => {
-    const chunk = chunks[head];
-    if (count === chunk.length) {
-      chunks[head] = EMPTY;
-      head = head + 1 & capacityMask;
-    } else
-      chunks[head] = chunk.subarray(count);
-    totalAvailable -= count;
-    if (totalAvailable === 0 && chunks.length > INITIAL_CAPACITY) {
-      chunks = new Array(INITIAL_CAPACITY);
-      capacityMask = INITIAL_CAPACITY - 1;
-      head = 0;
-      tail = 0;
-    }
-  };
-  function pull(bytes, callback) {
-    if (callback) {
-      let fed = 0;
-      let remaining$1 = Math.min(bytes, totalAvailable);
-      while (remaining$1 > 0) {
-        const chunk = chunks[head];
-        const toFeed = Math.min(remaining$1, chunk.length);
-        const segment = toFeed === chunk.length ? chunk : chunk.subarray(0, toFeed);
-        consumeFromHead(toFeed);
-        remaining$1 -= toFeed;
-        fed += toFeed;
-        if (!callback(segment))
-          break;
-      }
-      return fed;
-    }
-    if (totalAvailable < bytes)
-      return null;
-    if (bytes === 0)
-      return EMPTY;
-    const firstChunk = chunks[head];
-    if (firstChunk.length >= bytes) {
-      const view = firstChunk.length === bytes ? firstChunk : firstChunk.subarray(0, bytes);
-      consumeFromHead(bytes);
-      return view;
-    }
-    const result = new Uint8Array(bytes);
-    let copied = 0;
-    let remaining = bytes;
-    while (remaining > 0) {
-      const chunk = chunks[head];
-      const toCopy = Math.min(remaining, chunk.length);
-      result.set(toCopy === chunk.length ? chunk : chunk.subarray(0, toCopy), copied);
-      copied += toCopy;
-      remaining -= toCopy;
-      consumeFromHead(toCopy);
-    }
-    return result;
-  }
-  return {
-    push: (chunk) => {
-      if (chunk.length === 0)
-        return;
-      let nextTail = tail + 1 & capacityMask;
-      if (nextTail === head) {
-        const oldLen = chunks.length;
-        const newLen = oldLen * 2;
-        const newChunks = new Array(newLen);
-        const count = tail - head + oldLen & oldLen - 1;
-        if (head < tail)
-          for (let i = 0;i < count; i++)
-            newChunks[i] = chunks[head + i];
-        else if (count > 0) {
-          const firstPart = oldLen - head;
-          for (let i = 0;i < firstPart; i++)
-            newChunks[i] = chunks[head + i];
-          for (let i = 0;i < tail; i++)
-            newChunks[firstPart + i] = chunks[i];
-        }
-        chunks = newChunks;
-        capacityMask = newLen - 1;
-        head = 0;
-        tail = count;
-        nextTail = tail + 1 & capacityMask;
-      }
-      chunks[tail] = chunk;
-      tail = nextTail;
-      totalAvailable += chunk.length;
-    },
-    available: () => totalAvailable,
-    peek: (bytes) => {
-      if (totalAvailable < bytes)
-        return null;
-      if (bytes === 0)
-        return EMPTY;
-      const firstChunk = chunks[head];
-      if (firstChunk.length >= bytes)
-        return firstChunk.length === bytes ? firstChunk : firstChunk.subarray(0, bytes);
-      const result = new Uint8Array(bytes);
-      let copied = 0;
-      let index = head;
-      while (copied < bytes) {
-        const chunk = chunks[index];
-        const toCopy = Math.min(bytes - copied, chunk.length);
-        if (toCopy === chunk.length)
-          result.set(chunk, copied);
-        else
-          result.set(chunk.subarray(0, toCopy), copied);
-        copied += toCopy;
-        index = index + 1 & capacityMask;
-      }
-      return result;
-    },
-    discard: (bytes) => {
-      if (bytes > totalAvailable)
-        throw new Error("Too many bytes consumed");
-      if (bytes === 0)
-        return;
-      let remaining = bytes;
-      while (remaining > 0) {
-        const chunk = chunks[head];
-        const toConsume = Math.min(remaining, chunk.length);
-        consumeFromHead(toConsume);
-        remaining -= toConsume;
-      }
-    },
-    pull
-  };
-}
-var STATE_HEADER = 0;
-var STATE_BODY = 1;
-var truncateErr = /* @__PURE__ */ new Error("Tar archive is truncated.");
-function createUnpacker(options = {}) {
-  const strict = options.strict ?? false;
-  const { available, peek, push, discard, pull } = createChunkQueue();
-  let state = STATE_HEADER;
-  let ended = false;
-  let done = false;
-  let eof = false;
-  let currentEntry = null;
-  const paxGlobals = {};
-  let nextEntryOverrides = {};
-  const unpacker = {
-    isEntryActive: () => state === STATE_BODY,
-    isBodyComplete: () => !currentEntry || currentEntry.remaining === 0,
-    write(chunk) {
-      if (ended)
-        throw new Error("Archive already ended.");
-      push(chunk);
-    },
-    end() {
-      ended = true;
-    },
-    readHeader() {
-      if (state !== STATE_HEADER)
-        throw new Error("Cannot read header while an entry is active");
-      if (done)
-        return;
-      while (!done) {
-        if (available() < BLOCK_SIZE) {
-          if (ended) {
-            if (available() > 0 && strict)
-              throw truncateErr;
-            done = true;
-            return;
-          }
-          return null;
-        }
-        const headerBlock = peek(BLOCK_SIZE);
-        if (isZeroBlock(headerBlock)) {
-          if (available() < BLOCK_SIZE * 2) {
-            if (ended) {
-              if (strict)
-                throw truncateErr;
-              done = true;
-              return;
-            }
-            return null;
-          }
-          if (isZeroBlock(peek(BLOCK_SIZE * 2).subarray(BLOCK_SIZE))) {
-            discard(BLOCK_SIZE * 2);
-            done = true;
-            eof = true;
-            return;
-          }
-          if (strict)
-            throw new Error("Invalid tar header.");
-          discard(BLOCK_SIZE);
-          continue;
-        }
-        let internalHeader;
-        try {
-          internalHeader = parseUstarHeader(headerBlock, strict);
-        } catch (err) {
-          if (strict)
-            throw err;
-          discard(BLOCK_SIZE);
-          continue;
-        }
-        const metaParser = getMetaParser(internalHeader.type);
-        if (metaParser) {
-          const paddedSize = internalHeader.size + BLOCK_SIZE_MASK & ~BLOCK_SIZE_MASK;
-          if (available() < BLOCK_SIZE + paddedSize) {
-            if (ended && strict)
-              throw truncateErr;
-            return null;
-          }
-          discard(BLOCK_SIZE);
-          const overrides = metaParser(pull(paddedSize).subarray(0, internalHeader.size));
-          const target = internalHeader.type === "pax-global-header" ? paxGlobals : nextEntryOverrides;
-          for (const key in overrides)
-            target[key] = overrides[key];
-          continue;
-        }
-        discard(BLOCK_SIZE);
-        const header = internalHeader;
-        if (internalHeader.prefix)
-          header.name = `${internalHeader.prefix}/${header.name}`;
-        applyOverrides(header, paxGlobals);
-        applyOverrides(header, nextEntryOverrides);
-        nextEntryOverrides = {};
-        currentEntry = {
-          header,
-          remaining: header.size,
-          padding: -header.size & BLOCK_SIZE_MASK
-        };
-        state = STATE_BODY;
-        return header;
-      }
-    },
-    streamBody(callback) {
-      if (state !== STATE_BODY || !currentEntry || currentEntry.remaining === 0)
-        return 0;
-      const bytesToFeed = Math.min(currentEntry.remaining, available());
-      if (bytesToFeed === 0)
-        return 0;
-      const fed = pull(bytesToFeed, callback);
-      currentEntry.remaining -= fed;
-      return fed;
-    },
-    skipPadding() {
-      if (state !== STATE_BODY || !currentEntry)
-        return true;
-      if (currentEntry.remaining > 0)
-        throw new Error("Body not fully consumed");
-      if (available() < currentEntry.padding)
-        return false;
-      discard(currentEntry.padding);
-      currentEntry = null;
-      state = STATE_HEADER;
-      return true;
-    },
-    skipEntry() {
-      if (state !== STATE_BODY || !currentEntry)
-        return true;
-      const toDiscard = Math.min(currentEntry.remaining, available());
-      if (toDiscard > 0) {
-        discard(toDiscard);
-        currentEntry.remaining -= toDiscard;
-      }
-      if (currentEntry.remaining > 0)
-        return false;
-      return unpacker.skipPadding();
-    },
-    validateEOF() {
-      if (strict) {
-        if (!eof)
-          throw truncateErr;
-        if (available() > 0) {
-          if (pull(available()).some((byte) => byte !== 0))
-            throw new Error("Invalid EOF.");
-        }
-      }
-    }
-  };
-  return unpacker;
-}
-function isZeroBlock(block) {
-  if (block.byteOffset % 8 === 0) {
-    const view = new BigUint64Array(block.buffer, block.byteOffset, block.length / 8);
-    for (let i = 0;i < view.length; i++)
-      if (view[i] !== 0n)
-        return false;
-    return true;
-  }
-  for (let i = 0;i < block.length; i++)
-    if (block[i] !== 0)
-      return false;
-  return true;
-}
-function createTarPacker2() {
-  let streamController;
-  let packer;
-  return {
-    readable: new ReadableStream({ start(controller) {
-      streamController = controller;
-      packer = createTarPacker(controller.enqueue.bind(controller), controller.error.bind(controller), controller.close.bind(controller));
-    } }),
-    controller: {
-      add(header) {
-        const bodyless = isBodyless(header);
-        const h = { ...header };
-        if (bodyless)
-          h.size = 0;
-        packer.add(h);
-        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();
-  }
-}
-var drain = (stream) => stream.pipeTo(new WritableStream);
-function createTarDecoder(options = {}) {
-  const unpacker = createUnpacker(options);
-  let bodyController = null;
-  let pumping = false;
-  const pump = (controller) => {
-    if (pumping)
-      return;
-    pumping = true;
-    try {
-      while (true)
-        if (unpacker.isEntryActive()) {
-          if (bodyController) {
-            if (unpacker.streamBody((c) => (bodyController.enqueue(c), true)) === 0 && !unpacker.isBodyComplete())
-              break;
-          } else if (!unpacker.skipEntry())
-            break;
-          if (unpacker.isBodyComplete()) {
-            try {
-              bodyController?.close();
-            } catch {}
-            bodyController = null;
-            if (!unpacker.skipPadding())
-              break;
-          }
-        } else {
-          const header = unpacker.readHeader();
-          if (header === null || header === undefined)
-            break;
-          controller.enqueue({
-            header,
-            body: new ReadableStream({
-              start(c) {
-                if (header.size === 0)
-                  c.close();
-                else
-                  bodyController = c;
-              },
-              pull: () => pump(controller),
-              cancel() {
-                bodyController = null;
-                pump(controller);
-              }
-            })
-          });
-        }
-    } catch (error) {
-      try {
-        bodyController?.error(error);
-      } catch {}
-      bodyController = null;
-      throw error;
-    } finally {
-      pumping = false;
-    }
-  };
-  return new TransformStream({
-    transform(chunk, controller) {
-      try {
-        unpacker.write(chunk);
-        pump(controller);
-      } catch (error) {
-        try {
-          bodyController?.error(error);
-        } catch {}
-        throw error;
-      }
-    },
-    flush(controller) {
-      try {
-        unpacker.end();
-        pump(controller);
-        unpacker.validateEOF();
-        if (unpacker.isEntryActive() && !unpacker.isBodyComplete())
-          try {
-            bodyController?.close();
-          } catch {}
-      } catch (error) {
-        try {
-          bodyController?.error(error);
-        } catch {}
-        throw error;
-      }
-    }
-  }, undefined, { highWaterMark: 1 });
-}
-async function packTar(entries) {
-  const { readable, controller } = createTarPacker2();
-  await (async () => {
-    for (const entry of entries) {
-      const entryStream = controller.add(entry.header);
-      const body = "body" in entry ? entry.body : entry.data;
-      if (!body) {
-        await entryStream.close();
-        continue;
-      }
-      if (body instanceof ReadableStream)
-        await body.pipeTo(entryStream);
-      else if (body instanceof Blob)
-        await body.stream().pipeTo(entryStream);
-      else
-        try {
-          const chunk = await normalizeBody(body);
-          if (chunk.length > 0) {
-            const writer = entryStream.getWriter();
-            await writer.write(chunk);
-            await writer.close();
-          } else
-            await entryStream.close();
-        } catch {
-          throw new TypeError(`Unsupported content type for entry "${entry.header.name}".`);
-        }
-    }
-  })().then(() => controller.finalize()).catch((err) => controller.error(err));
-  return new Uint8Array(await streamToBuffer(readable));
-}
-async function unpackTar(archive, options = {}) {
-  const sourceStream = archive instanceof ReadableStream ? archive : new ReadableStream({ start(controller) {
-    controller.enqueue(archive instanceof Uint8Array ? archive : new Uint8Array(archive));
-    controller.close();
-  } });
-  const results = [];
-  const entryStream = sourceStream.pipeThrough(createTarDecoder(options));
-  for await (const entry of entryStream) {
-    let processedHeader;
-    try {
-      processedHeader = transformHeader(entry.header, options);
-    } catch (error) {
-      await entry.body.cancel();
-      throw error;
-    }
-    if (processedHeader === null) {
-      await drain(entry.body);
-      continue;
-    }
-    if (isBodyless(processedHeader)) {
-      await drain(entry.body);
-      results.push({ header: processedHeader });
-    } else
-      results.push({
-        header: processedHeader,
-        data: await streamToBuffer(entry.body)
-      });
-  }
-  return results;
-}
 var gzipAsync = promisify(gzip);
 var gunzipAsync = promisify(gunzip);
 
-class RXPImpl {
-  _files;
-  _pathsCache = null;
-  _treeCache = null;
-  constructor(files) {
-    this._files = files;
-  }
-  paths() {
-    if (this._pathsCache) {
-      return this._pathsCache;
-    }
-    this._pathsCache = Array.from(this._files.keys()).sort();
-    return this._pathsCache;
-  }
-  tree() {
-    if (this._treeCache) {
-      return this._treeCache;
-    }
-    const root = new Map;
-    for (const path of this._files.keys()) {
-      const parts = path.split("/");
-      let currentLevel = root;
-      for (let i = 0;i < parts.length; i++) {
-        const part = parts[i];
-        const isFile = i === parts.length - 1;
-        if (!currentLevel.has(part)) {
-          const treeNode2 = {
-            node: {
-              name: part,
-              type: isFile ? "file" : "directory",
-              children: isFile ? undefined : []
-            },
-            children: new Map
-          };
-          currentLevel.set(part, treeNode2);
-        }
-        const treeNode = currentLevel.get(part);
-        if (!isFile) {
-          currentLevel = treeNode.children;
-        }
-      }
-    }
-    const convertToPathNodes = (level) => {
-      return Array.from(level.values()).map((treeNode) => {
-        if (treeNode.node.type === "directory" && treeNode.children.size > 0) {
-          treeNode.node.children = convertToPathNodes(treeNode.children);
-        }
-        return treeNode.node;
-      });
-    };
-    this._treeCache = convertToPathNodes(root);
-    return this._treeCache;
-  }
-  async file(path) {
-    const content = this._files.get(path);
-    if (!content) {
-      throw new ContentError(`file not found: ${path}`);
-    }
-    return content;
-  }
-  async files() {
-    return new Map(this._files);
-  }
-  async pack() {
-    const filesRecord = {};
-    for (const [path, content] of this._files) {
-      filesRecord[path] = content;
-    }
-    return createRXA(filesRecord);
-  }
-}
-
-class RXAImpl {
-  _buffer;
-  _rxpCache = null;
-  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 extract() {
-    if (this._rxpCache) {
-      return this._rxpCache;
-    }
-    const tarBuffer = await gunzipAsync(this._buffer);
-    const entries = await unpackTar(tarBuffer);
-    const filesMap = new Map;
-    for (const entry of entries) {
-      if ((entry.header.type === "file" || entry.header.type === undefined) && entry.data) {
-        filesMap.set(entry.header.name, Buffer.from(entry.data));
-      }
-    }
-    this._rxpCache = new RXPImpl(filesMap);
-    return this._rxpCache;
-  }
-}
-function isBufferInput(input) {
-  return "buffer" in input && Buffer.isBuffer(input.buffer);
-}
-async function createRXA(input) {
-  if (isBufferInput(input)) {
-    return new RXAImpl(input.buffer);
-  }
-  const entries = Object.entries(input).map(([name, content]) => {
-    const body = typeof content === "string" ? content : content instanceof Uint8Array ? content : new Uint8Array(content);
-    const size = typeof content === "string" ? Buffer.byteLength(content) : content.length;
-    return {
-      header: { name, size, type: "file" },
-      body
-    };
-  });
-  const tarBuffer = await packTar(entries);
-  const gzipBuffer = await gzipAsync(Buffer.from(tarBuffer));
-  return new RXAImpl(gzipBuffer);
-}
-
 // src/errors.ts
 class ResourceTypeError extends ResourceXError {
   constructor(message) {
@@ -1193,117 +63,67 @@ class ResourceTypeError extends ResourceXError {
   }
 }
 // src/builtinTypes.ts
-var textSerializer = {
-  async serialize(rxr) {
-    return rxr.archive.buffer();
-  },
-  async deserialize(data, manifest) {
-    return {
-      locator: parseRXL(manifest.toLocator()),
-      manifest,
-      archive: await createRXA({ buffer: data })
-    };
-  }
-};
-var textResolver = {
-  schema: undefined,
-  async resolve(rxr) {
-    return {
-      resource: rxr,
-      schema: undefined,
-      execute: async () => {
-        const pkg = await rxr.archive.extract();
-        const buffer = await pkg.file("content");
-        return buffer.toString("utf-8");
-      }
-    };
-  }
-};
 var textType = {
   name: "text",
   aliases: ["txt", "plaintext"],
   description: "Plain text content",
-  serializer: textSerializer,
-  resolver: textResolver
-};
-var jsonSerializer = {
-  async serialize(rxr) {
-    return rxr.archive.buffer();
-  },
-  async deserialize(data, manifest) {
-    return {
-      locator: parseRXL(manifest.toLocator()),
-      manifest,
-      archive: await createRXA({ buffer: data })
-    };
-  }
-};
-var jsonResolver = {
-  schema: undefined,
-  async resolve(rxr) {
-    return {
-      resource: rxr,
-      schema: undefined,
-      execute: async () => {
-        const pkg = await rxr.archive.extract();
-        const buffer = await pkg.file("content");
-        return JSON.parse(buffer.toString("utf-8"));
-      }
-    };
+  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);
   }
+};`
 };
 var jsonType = {
   name: "json",
   aliases: ["config", "manifest"],
   description: "JSON content",
-  serializer: jsonSerializer,
-  resolver: jsonResolver
-};
-var binarySerializer = {
-  async serialize(rxr) {
-    return rxr.archive.buffer();
-  },
-  async deserialize(data, manifest) {
-    return {
-      locator: parseRXL(manifest.toLocator()),
-      manifest,
-      archive: await createRXA({ buffer: data })
-    };
-  }
-};
-var binaryResolver = {
-  schema: undefined,
-  async resolve(rxr) {
-    return {
-      resource: rxr,
-      schema: undefined,
-      execute: async () => {
-        const pkg = await rxr.archive.extract();
-        return pkg.file("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));
   }
+};`
 };
 var binaryType = {
   name: "binary",
   aliases: ["bin", "blob", "raw"],
   description: "Binary content",
-  serializer: binarySerializer,
-  resolver: binaryResolver
+  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"];
+  }
+};`
 };
 var builtinTypes = [textType, jsonType, binaryType];
+
 // src/TypeHandlerChain.ts
 class TypeHandlerChain {
   handlers = new Map;
   constructor() {
     for (const type of builtinTypes) {
-      this.registerBuiltin(type);
+      this.registerInternal(type);
     }
   }
   static create() {
     return new TypeHandlerChain;
   }
-  registerBuiltin(type) {
+  registerInternal(type) {
     this.handlers.set(type.name, type);
     if (type.aliases) {
       for (const alias of type.aliases) {
@@ -1329,49 +149,30 @@ class TypeHandlerChain {
     return this.handlers.has(typeName);
   }
   getHandler(typeName) {
-    return this.handlers.get(typeName);
-  }
-  getSupportedTypes() {
-    return Array.from(this.handlers.keys());
-  }
-  async serialize(rxr) {
-    const typeName = rxr.manifest.type;
     const handler = this.handlers.get(typeName);
     if (!handler) {
       throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
     }
-    return handler.serializer.serialize(rxr);
+    return handler;
   }
-  async deserialize(data, manifest) {
-    const typeName = manifest.type;
-    const handler = this.handlers.get(typeName);
-    if (!handler) {
-      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
-    }
-    return handler.serializer.deserialize(data, manifest);
+  getHandlerOrUndefined(typeName) {
+    return this.handlers.get(typeName);
   }
-  async resolve(rxr) {
-    const typeName = rxr.manifest.type;
-    const handler = this.handlers.get(typeName);
-    if (!handler) {
-      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);
-    }
-    return handler.resolver.resolve(rxr);
+  getSupportedTypes() {
+    return Array.from(this.handlers.keys());
   }
-  clearExtensions() {
+  clear() {
     this.handlers.clear();
-    for (const type of builtinTypes) {
-      this.registerBuiltin(type);
-    }
   }
 }
 export {
   textType,
   jsonType,
+  bundleResourceType,
   builtinTypes,
   binaryType,
   TypeHandlerChain,
   ResourceTypeError
 };
 
-//# debugId=B5634954AD5377ED64756E2164756E21
+//# debugId=9BB0B47B5E1F216964756E2164756E21