@resourcexjs/type 1.0.0

package/README.md

@@ -0,0 +1,297 @@
+# @resourcexjs/type
+
+Type system for ResourceX with global singleton TypeHandlerChain.
+
+## Installation
+
+```bash
+bun add @resourcexjs/type
+```
+
+## Overview
+
+The `@resourcexjs/type` package provides the type system for ResourceX, managing how different resource types are serialized, deserialized, and resolved.
+
+### Key Concepts
+
+- **ResourceType**: Defines how a resource type is handled (serialization, deserialization, resolution)
+- **TypeHandlerChain**: Global singleton managing all registered types
+- **Builtin Types**: Text, JSON, and Binary types are automatically registered
+
+## Usage
+
+### Using Builtin Types
+
+Builtin types are automatically available:
+
+```typescript
+import { globalTypeHandlerChain } from "@resourcexjs/type";
+
+// Check if type is supported
+globalTypeHandlerChain.canHandle("text"); // true
+globalTypeHandlerChain.canHandle("json"); // true
+globalTypeHandlerChain.canHandle("binary"); // true
+
+// Builtin aliases
+globalTypeHandlerChain.canHandle("txt"); // true (alias for text)
+globalTypeHandlerChain.canHandle("config"); // true (alias for json)
+```
+
+### Registering Custom Types
+
+```typescript
+import { globalTypeHandlerChain } from "@resourcexjs/type";
+import type { ResourceType } from "@resourcexjs/type";
+
+// Define custom type
+const promptType: ResourceType<string> = {
+  name: "prompt",
+  aliases: ["deepractice-prompt"],
+  description: "AI Prompt template",
+  serializer: {
+    async serialize(rxr) {
+      const text = await rxr.content.text();
+      return Buffer.from(text, "utf-8");
+    },
+    async deserialize(data, manifest) {
+      // ... implementation
+    },
+  },
+  resolver: {
+    async resolve(rxr) {
+      return rxr.content.text();
+    },
+  },
+};
+
+// Register globally
+globalTypeHandlerChain.register(promptType);
+```
+
+### Query Supported Types
+
+```typescript
+import { globalTypeHandlerChain } from "@resourcexjs/type";
+
+// Get all supported types (including aliases)
+const types = globalTypeHandlerChain.getSupportedTypes();
+// ["text", "txt", "plaintext", "json", "config", "manifest", "binary", "bin", "blob", "raw"]
+
+// Get handler for specific type
+const handler = globalTypeHandlerChain.getHandler("text");
+console.log(handler?.name); // "text"
+```
+
+### Serialize/Deserialize
+
+```typescript
+import { globalTypeHandlerChain } from "@resourcexjs/type";
+import { createRXM, createRXC, parseRXL } from "@resourcexjs/core";
+
+// Serialize RXR to Buffer
+const manifest = createRXM({
+  domain: "localhost",
+  name: "test",
+  type: "text",
+  version: "1.0.0",
+});
+
+const rxr = {
+  locator: parseRXL(manifest.toLocator()),
+  manifest,
+  content: createRXC("Hello, World!"),
+};
+
+const buffer = await globalTypeHandlerChain.serialize(rxr);
+// Buffer containing "Hello, World!"
+
+// Deserialize Buffer to RXR
+const restored = await globalTypeHandlerChain.deserialize(buffer, manifest);
+console.log(await restored.content.text()); // "Hello, World!"
+```
+
+### Resolve Content
+
+```typescript
+import { globalTypeHandlerChain } from "@resourcexjs/type";
+
+// Resolve RXR to usable object
+const text = await globalTypeHandlerChain.resolve<string>(rxr);
+console.log(text); // "Hello, World!"
+```
+
+## API Reference
+
+### `globalTypeHandlerChain`
+
+Global singleton instance of TypeHandlerChain.
+
+#### Methods
+
+##### `register(type: ResourceType): void`
+
+Register an extension type.
+
+**Throws**: `ResourceTypeError` if type name or alias already exists.
+
+```typescript
+globalTypeHandlerChain.register(customType);
+```
+
+##### `canHandle(typeName: string): boolean`
+
+Check if a type is supported.
+
+```typescript
+globalTypeHandlerChain.canHandle("text"); // true
+```
+
+##### `getHandler(typeName: string): ResourceType | undefined`
+
+Get handler for a type.
+
+```typescript
+const handler = globalTypeHandlerChain.getHandler("text");
+```
+
+##### `getSupportedTypes(): string[]`
+
+Get all supported type names (including aliases).
+
+```typescript
+const types = globalTypeHandlerChain.getSupportedTypes();
+```
+
+##### `serialize(rxr: RXR): Promise<Buffer>`
+
+Serialize RXR to Buffer using appropriate type handler.
+
+**Throws**: `ResourceTypeError` if type not supported.
+
+##### `deserialize(data: Buffer, manifest: RXM): Promise<RXR>`
+
+Deserialize Buffer to RXR using appropriate type handler.
+
+**Throws**: `ResourceTypeError` if type not supported.
+
+##### `resolve<T>(rxr: RXR): Promise<T>`
+
+Resolve RXR content to usable object using appropriate type handler.
+
+**Throws**: `ResourceTypeError` if type not supported.
+
+##### `clearExtensions(): void`
+
+Clear all extension types (for testing). Builtin types remain.
+
+```typescript
+globalTypeHandlerChain.clearExtensions();
+```
+
+## Builtin Types
+
+### Text Type
+
+- **Name**: `text`
+- **Aliases**: `txt`, `plaintext`
+- **Storage**: UTF-8 encoded string
+- **Resolves to**: `string`
+
+### JSON Type
+
+- **Name**: `json`
+- **Aliases**: `config`, `manifest`
+- **Storage**: Formatted JSON string
+- **Resolves to**: `unknown` (parsed object)
+
+### Binary Type
+
+- **Name**: `binary`
+- **Aliases**: `bin`, `blob`, `raw`
+- **Storage**: Raw bytes
+- **Resolves to**: `Buffer`
+
+## Type System Architecture
+
+```
+┌─────────────────────────────────────────┐
+│   globalTypeHandlerChain (Singleton)    │
+│                                         │
+│   Builtin: text, json, binary          │
+│   Extensions: custom types...           │
+└─────────────────────────────────────────┘
+              ↑
+              │
+         All packages use
+         global singleton
+```
+
+## Creating Custom Types
+
+### Example: Prompt Type
+
+```typescript
+import type { ResourceType } from "@resourcexjs/type";
+import { createRXC, parseRXL } from "@resourcexjs/core";
+
+export const promptType: ResourceType<string> = {
+  name: "prompt",
+  aliases: ["deepractice-prompt"],
+  description: "AI Prompt template with variable substitution",
+
+  serializer: {
+    async serialize(rxr) {
+      const text = await rxr.content.text();
+      return Buffer.from(text, "utf-8");
+    },
+
+    async deserialize(data, manifest) {
+      const text = data.toString("utf-8");
+      return {
+        locator: parseRXL(manifest.toLocator()),
+        manifest,
+        content: createRXC(text),
+      };
+    },
+  },
+
+  resolver: {
+    async resolve(rxr) {
+      // Custom resolution logic
+      const template = await rxr.content.text();
+      return template;
+    },
+  },
+};
+```
+
+## Error Handling
+
+```typescript
+import { ResourceTypeError } from "@resourcexjs/type";
+
+try {
+  await globalTypeHandlerChain.serialize(rxr);
+} catch (error) {
+  if (error instanceof ResourceTypeError) {
+    console.error("Type error:", error.message);
+  }
+}
+```
+
+## Testing
+
+When testing, use `clearExtensions()` to reset extension types:
+
+```typescript
+import { afterEach } from "bun:test";
+import { globalTypeHandlerChain } from "@resourcexjs/type";
+
+afterEach(() => {
+  globalTypeHandlerChain.clearExtensions();
+});
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,132 @@
+import { RXR, RXM } from "@resourcexjs/core";
+/**
+* ResourceSerializer - Handles RXR serialization/deserialization for storage.
+*/
+interface ResourceSerializer {
+	/**
+	* Serialize RXR to storage format.
+	*/
+	serialize(rxr: RXR): Promise<Buffer>;
+	/**
+	* Deserialize storage data to RXR.
+	*/
+	deserialize(data: Buffer, manifest: RXM): Promise<RXR>;
+}
+/**
+* ResourceResolver - Transforms RXR into usable object.
+*/
+interface ResourceResolver<T = unknown> {
+	/**
+	* Resolve RXR content into a usable object.
+	*/
+	resolve(rxr: RXR): Promise<T>;
+}
+/**
+* ResourceType - Defines how a resource type is handled.
+*/
+interface ResourceType<T = unknown> {
+	/**
+	* Type name (e.g., "text", "json", "binary").
+	*/
+	name: string;
+	/**
+	* Alternative names for this type (e.g., ["txt", "plaintext"]).
+	*/
+	aliases?: string[];
+	/**
+	* Human-readable description.
+	*/
+	description: string;
+	/**
+	* Serializer for storage operations.
+	*/
+	serializer: ResourceSerializer;
+	/**
+	* Resolver to transform RXR into usable object.
+	*/
+	resolver: ResourceResolver<T>;
+}
+import { ResourceXError } from "@resourcexjs/core";
+/**
+* Resource type related error.
+*/
+declare class ResourceTypeError extends ResourceXError {
+	constructor(message: string);
+}
+/**
+* Text resource type
+*/
+declare const textType: ResourceType<string>;
+/**
+* JSON resource type
+*/
+declare const jsonType: ResourceType<unknown>;
+/**
+* Binary resource type
+*/
+declare const binaryType: ResourceType<Buffer>;
+/**
+* All built-in types
+*/
+declare const builtinTypes: ResourceType[];
+import { RXR as RXR2, RXM as RXM2 } from "@resourcexjs/core";
+/**
+* TypeHandlerChain - Global singleton for type handling.
+* Manages type registration and delegates serialization/deserialization.
+*/
+declare class TypeHandlerChain {
+	private static instance;
+	private handlers;
+	private constructor();
+	/**
+	* Get the global singleton instance.
+	*/
+	static getInstance(): TypeHandlerChain;
+	/**
+	* Register a builtin type (private, called during initialization).
+	*/
+	private registerBuiltin;
+	/**
+	* Register an extension type (public, for user-defined types).
+	* @throws ResourceTypeError if type is already registered
+	*/
+	register(type: ResourceType): void;
+	/**
+	* Check if a type is supported.
+	*/
+	canHandle(typeName: string): boolean;
+	/**
+	* Get handler for a type.
+	*/
+	getHandler(typeName: string): ResourceType | undefined;
+	/**
+	* Get all supported type names (including aliases).
+	*/
+	getSupportedTypes(): string[];
+	/**
+	* Serialize RXR content using the appropriate type handler.
+	* @throws ResourceTypeError if type is not supported
+	*/
+	serialize(rxr: RXR2): Promise<Buffer>;
+	/**
+	* Deserialize content into RXR using the appropriate type handler.
+	* @throws ResourceTypeError if type is not supported
+	*/
+	deserialize(data: Buffer, manifest: RXM2): Promise<RXR2>;
+	/**
+	* Resolve RXR content into usable object using the appropriate type handler.
+	* @throws ResourceTypeError if type is not supported
+	*/
+	resolve<T = unknown>(rxr: RXR2): Promise<T>;
+	/**
+	* Clear all extension types (for testing).
+	* Keeps builtin types intact.
+	*/
+	clearExtensions(): void;
+}
+/**
+* Global singleton instance of TypeHandlerChain.
+* All type registration and handling goes through this instance.
+*/
+declare const globalTypeHandlerChain: TypeHandlerChain;
+export { textType, jsonType, globalTypeHandlerChain, builtinTypes, binaryType, TypeHandlerChain, ResourceTypeError, ResourceType, ResourceSerializer, ResourceResolver };

package/dist/index.js

@@ -0,0 +1,316 @@
+// ../core/dist/index.js
+class ResourceXError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    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 });
+}
+class RXCImpl {
+  _stream;
+  _consumed = false;
+  constructor(stream) {
+    this._stream = stream;
+  }
+  get stream() {
+    if (this._consumed) {
+      throw new ContentError("Content has already been consumed");
+    }
+    this._consumed = true;
+    return this._stream;
+  }
+  async text() {
+    const buffer = await this.buffer();
+    return buffer.toString("utf-8");
+  }
+  async buffer() {
+    if (this._consumed) {
+      throw new ContentError("Content has already been consumed");
+    }
+    this._consumed = true;
+    const reader = this._stream.getReader();
+    const chunks = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      chunks.push(value);
+    }
+    return Buffer.concat(chunks);
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+}
+function createRXC(data) {
+  let stream;
+  if (typeof data === "string") {
+    const encoded = new TextEncoder().encode(data);
+    stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoded);
+        controller.close();
+      }
+    });
+  } else if (Buffer.isBuffer(data)) {
+    stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(data));
+        controller.close();
+      }
+    });
+  } else {
+    stream = data;
+  }
+  return new RXCImpl(stream);
+}
+
+// src/errors.ts
+class ResourceTypeError extends ResourceXError {
+  constructor(message) {
+    super(message);
+    this.name = "ResourceTypeError";
+  }
+}
+// src/builtinTypes.ts
+var textSerializer = {
+  async serialize(rxr) {
+    const text = await rxr.content.text();
+    return Buffer.from(text, "utf-8");
+  },
+  async deserialize(data, manifest) {
+    const text = data.toString("utf-8");
+    return {
+      locator: parseRXL(manifest.toLocator()),
+      manifest,
+      content: createRXC(text)
+    };
+  }
+};
+var textResolver = {
+  async resolve(rxr) {
+    return rxr.content.text();
+  }
+};
+var textType = {
+  name: "text",
+  aliases: ["txt", "plaintext"],
+  description: "Plain text content",
+  serializer: textSerializer,
+  resolver: textResolver
+};
+var jsonSerializer = {
+  async serialize(rxr) {
+    const json = await rxr.content.json();
+    return Buffer.from(JSON.stringify(json, null, 2), "utf-8");
+  },
+  async deserialize(data, manifest) {
+    const text = data.toString("utf-8");
+    return {
+      locator: parseRXL(manifest.toLocator()),
+      manifest,
+      content: createRXC(text)
+    };
+  }
+};
+var jsonResolver = {
+  async resolve(rxr) {
+    return rxr.content.json();
+  }
+};
+var jsonType = {
+  name: "json",
+  aliases: ["config", "manifest"],
+  description: "JSON content",
+  serializer: jsonSerializer,
+  resolver: jsonResolver
+};
+var binarySerializer = {
+  async serialize(rxr) {
+    return rxr.content.buffer();
+  },
+  async deserialize(data, manifest) {
+    return {
+      locator: parseRXL(manifest.toLocator()),
+      manifest,
+      content: createRXC(data)
+    };
+  }
+};
+var binaryResolver = {
+  async resolve(rxr) {
+    return rxr.content.buffer();
+  }
+};
+var binaryType = {
+  name: "binary",
+  aliases: ["bin", "blob", "raw"],
+  description: "Binary content",
+  serializer: binarySerializer,
+  resolver: binaryResolver
+};
+var builtinTypes = [textType, jsonType, binaryType];
+// src/TypeHandlerChain.ts
+class TypeHandlerChain {
+  static instance;
+  handlers = new Map;
+  constructor() {
+    for (const type of builtinTypes) {
+      this.registerBuiltin(type);
+    }
+  }
+  static getInstance() {
+    if (!TypeHandlerChain.instance) {
+      TypeHandlerChain.instance = new TypeHandlerChain;
+    }
+    return TypeHandlerChain.instance;
+  }
+  registerBuiltin(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) {
+    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);
+  }
+  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);
+  }
+  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);
+  }
+  clearExtensions() {
+    this.handlers.clear();
+    for (const type of builtinTypes) {
+      this.registerBuiltin(type);
+    }
+  }
+}
+var globalTypeHandlerChain = TypeHandlerChain.getInstance();
+export {
+  textType,
+  jsonType,
+  globalTypeHandlerChain,
+  builtinTypes,
+  binaryType,
+  TypeHandlerChain,
+  ResourceTypeError
+};
+
+//# debugId=ED28E038CDB29DF864756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../../core/dist/index.js", "../src/errors.ts", "../src/builtinTypes.ts", "../src/TypeHandlerChain.ts"],
+  "sourcesContent": [
+    "// src/errors.ts\nclass ResourceXError extends Error {\n  constructor(message, options) {\n    super(message, options);\n    this.name = \"ResourceXError\";\n  }\n}\n\nclass LocatorError extends ResourceXError {\n  locator;\n  constructor(message, locator) {\n    super(message);\n    this.locator = locator;\n    this.name = \"LocatorError\";\n  }\n}\n\nclass ManifestError extends ResourceXError {\n  constructor(message) {\n    super(message);\n    this.name = \"ManifestError\";\n  }\n}\n\nclass ContentError extends ResourceXError {\n  constructor(message) {\n    super(message);\n    this.name = \"ContentError\";\n  }\n}\n// src/locator/parseRXL.ts\nclass RXLImpl {\n  domain;\n  path;\n  name;\n  type;\n  version;\n  constructor(parts) {\n    this.domain = parts.domain;\n    this.path = parts.path;\n    this.name = parts.name;\n    this.type = parts.type;\n    this.version = parts.version;\n  }\n  toString() {\n    let result = \"\";\n    if (this.domain) {\n      result += this.domain + \"/\";\n      if (this.path) {\n        result += this.path + \"/\";\n      }\n    }\n    result += this.name;\n    if (this.type) {\n      result += \".\" + this.type;\n    }\n    if (this.version) {\n      result += \"@\" + this.version;\n    }\n    return result;\n  }\n}\nfunction isDomain(str) {\n  if (str === \"localhost\")\n    return true;\n  return str.includes(\".\");\n}\nfunction parseRXL(locator) {\n  let remaining = locator;\n  let version;\n  let type;\n  let domain;\n  let path;\n  let name;\n  const atIndex = remaining.indexOf(\"@\");\n  if (atIndex !== -1) {\n    version = remaining.slice(atIndex + 1);\n    remaining = remaining.slice(0, atIndex);\n  }\n  const segments = remaining.split(\"/\");\n  if (segments.length > 1 && isDomain(segments[0])) {\n    domain = segments[0];\n    const lastSegment = segments[segments.length - 1];\n    if (segments.length > 2) {\n      path = segments.slice(1, -1).join(\"/\");\n    }\n    remaining = lastSegment;\n  } else {\n    remaining = segments.join(\"/\");\n  }\n  const dotIndex = remaining.lastIndexOf(\".\");\n  if (dotIndex !== -1) {\n    type = remaining.slice(dotIndex + 1);\n    name = remaining.slice(0, dotIndex);\n  } else {\n    name = remaining;\n  }\n  return new RXLImpl({ domain, path, name, type, version });\n}\n// src/manifest/createRXM.ts\nclass RXMImpl {\n  domain;\n  path;\n  name;\n  type;\n  version;\n  constructor(data) {\n    this.domain = data.domain;\n    this.path = data.path;\n    this.name = data.name;\n    this.type = data.type;\n    this.version = data.version;\n  }\n  toLocator() {\n    let result = this.domain + \"/\";\n    if (this.path) {\n      result += this.path + \"/\";\n    }\n    result += this.name;\n    result += \".\" + this.type;\n    result += \"@\" + this.version;\n    return result;\n  }\n  toJSON() {\n    const json = {\n      domain: this.domain,\n      name: this.name,\n      type: this.type,\n      version: this.version\n    };\n    if (this.path !== undefined) {\n      json.path = this.path;\n    }\n    return json;\n  }\n}\nfunction createRXM(data) {\n  if (!data.domain) {\n    throw new ManifestError(\"domain is required\");\n  }\n  if (!data.name) {\n    throw new ManifestError(\"name is required\");\n  }\n  if (!data.type) {\n    throw new ManifestError(\"type is required\");\n  }\n  if (!data.version) {\n    throw new ManifestError(\"version is required\");\n  }\n  return new RXMImpl({\n    domain: data.domain,\n    path: data.path,\n    name: data.name,\n    type: data.type,\n    version: data.version\n  });\n}\n// src/content/createRXC.ts\nclass RXCImpl {\n  _stream;\n  _consumed = false;\n  constructor(stream) {\n    this._stream = stream;\n  }\n  get stream() {\n    if (this._consumed) {\n      throw new ContentError(\"Content has already been consumed\");\n    }\n    this._consumed = true;\n    return this._stream;\n  }\n  async text() {\n    const buffer = await this.buffer();\n    return buffer.toString(\"utf-8\");\n  }\n  async buffer() {\n    if (this._consumed) {\n      throw new ContentError(\"Content has already been consumed\");\n    }\n    this._consumed = true;\n    const reader = this._stream.getReader();\n    const chunks = [];\n    while (true) {\n      const { done, value } = await reader.read();\n      if (done)\n        break;\n      chunks.push(value);\n    }\n    return Buffer.concat(chunks);\n  }\n  async json() {\n    const text = await this.text();\n    return JSON.parse(text);\n  }\n}\nfunction createRXC(data) {\n  let stream;\n  if (typeof data === \"string\") {\n    const encoded = new TextEncoder().encode(data);\n    stream = new ReadableStream({\n      start(controller) {\n        controller.enqueue(encoded);\n        controller.close();\n      }\n    });\n  } else if (Buffer.isBuffer(data)) {\n    stream = new ReadableStream({\n      start(controller) {\n        controller.enqueue(new Uint8Array(data));\n        controller.close();\n      }\n    });\n  } else {\n    stream = data;\n  }\n  return new RXCImpl(stream);\n}\n// src/content/loadRXC.ts\nimport { createReadStream } from \"node:fs\";\nimport { Readable } from \"node:stream\";\nasync function loadRXC(source) {\n  if (source.startsWith(\"http://\") || source.startsWith(\"https://\")) {\n    const response = await fetch(source);\n    if (!response.ok) {\n      throw new Error(`Failed to fetch ${source}: ${response.statusText}`);\n    }\n    if (!response.body) {\n      throw new Error(`No body in response from ${source}`);\n    }\n    return createRXC(response.body);\n  }\n  const nodeStream = createReadStream(source);\n  const webStream = Readable.toWeb(nodeStream);\n  return createRXC(webStream);\n}\nexport {\n  parseRXL,\n  loadRXC,\n  createRXM,\n  createRXC,\n  ResourceXError,\n  ManifestError,\n  LocatorError,\n  ContentError\n};\n\n//# debugId=2AAEFC45892A016E64756E2164756E21\n",
+    "import { ResourceXError } from \"@resourcexjs/core\";\n\n/**\n * Resource type related error.\n */\nexport class ResourceTypeError extends ResourceXError {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ResourceTypeError\";\n  }\n}\n",
+    "import type { ResourceType, ResourceSerializer, ResourceResolver } from \"./types.js\";\nimport type { RXR, RXM } from \"@resourcexjs/core\";\nimport { createRXC, parseRXL } from \"@resourcexjs/core\";\n\n/**\n * Text serializer - stores content as UTF-8 text\n */\nconst textSerializer: ResourceSerializer = {\n  async serialize(rxr: RXR): Promise<Buffer> {\n    const text = await rxr.content.text();\n    return Buffer.from(text, \"utf-8\");\n  },\n\n  async deserialize(data: Buffer, manifest: RXM): Promise<RXR> {\n    const text = data.toString(\"utf-8\");\n    return {\n      locator: parseRXL(manifest.toLocator()),\n      manifest,\n      content: createRXC(text),\n    };\n  },\n};\n\n/**\n * Text resolver - returns content as string\n */\nconst textResolver: ResourceResolver<string> = {\n  async resolve(rxr: RXR): Promise<string> {\n    return rxr.content.text();\n  },\n};\n\n/**\n * Text resource type\n */\nexport const textType: ResourceType<string> = {\n  name: \"text\",\n  aliases: [\"txt\", \"plaintext\"],\n  description: \"Plain text content\",\n  serializer: textSerializer,\n  resolver: textResolver,\n};\n\n/**\n * JSON serializer - stores content as JSON string\n */\nconst jsonSerializer: ResourceSerializer = {\n  async serialize(rxr: RXR): Promise<Buffer> {\n    const json = await rxr.content.json();\n    return Buffer.from(JSON.stringify(json, null, 2), \"utf-8\");\n  },\n\n  async deserialize(data: Buffer, manifest: RXM): Promise<RXR> {\n    const text = data.toString(\"utf-8\");\n    return {\n      locator: parseRXL(manifest.toLocator()),\n      manifest,\n      content: createRXC(text),\n    };\n  },\n};\n\n/**\n * JSON resolver - returns content as parsed object\n */\nconst jsonResolver: ResourceResolver<unknown> = {\n  async resolve(rxr: RXR): Promise<unknown> {\n    return rxr.content.json();\n  },\n};\n\n/**\n * JSON resource type\n */\nexport const jsonType: ResourceType<unknown> = {\n  name: \"json\",\n  aliases: [\"config\", \"manifest\"],\n  description: \"JSON content\",\n  serializer: jsonSerializer,\n  resolver: jsonResolver,\n};\n\n/**\n * Binary serializer - stores content as raw bytes\n */\nconst binarySerializer: ResourceSerializer = {\n  async serialize(rxr: RXR): Promise<Buffer> {\n    return rxr.content.buffer();\n  },\n\n  async deserialize(data: Buffer, manifest: RXM): Promise<RXR> {\n    return {\n      locator: parseRXL(manifest.toLocator()),\n      manifest,\n      content: createRXC(data),\n    };\n  },\n};\n\n/**\n * Binary resolver - returns content as Buffer\n */\nconst binaryResolver: ResourceResolver<Buffer> = {\n  async resolve(rxr: RXR): Promise<Buffer> {\n    return rxr.content.buffer();\n  },\n};\n\n/**\n * Binary resource type\n */\nexport const binaryType: ResourceType<Buffer> = {\n  name: \"binary\",\n  aliases: [\"bin\", \"blob\", \"raw\"],\n  description: \"Binary content\",\n  serializer: binarySerializer,\n  resolver: binaryResolver,\n};\n\n/**\n * All built-in types\n */\nexport const builtinTypes: ResourceType[] = [textType, jsonType, binaryType];\n",
+    "import type { ResourceType } from \"./types.js\";\nimport type { RXR, RXM } from \"@resourcexjs/core\";\nimport { ResourceTypeError } from \"./errors.js\";\nimport { builtinTypes } from \"./builtinTypes.js\";\n\n/**\n * TypeHandlerChain - Global singleton for type handling.\n * Manages type registration and delegates serialization/deserialization.\n */\nexport class TypeHandlerChain {\n  private static instance: TypeHandlerChain;\n  private handlers: Map<string, ResourceType> = new Map();\n\n  private constructor() {\n    // Auto-register builtin types\n    for (const type of builtinTypes) {\n      this.registerBuiltin(type);\n    }\n  }\n\n  /**\n   * Get the global singleton instance.\n   */\n  static getInstance(): TypeHandlerChain {\n    if (!TypeHandlerChain.instance) {\n      TypeHandlerChain.instance = new TypeHandlerChain();\n    }\n    return TypeHandlerChain.instance;\n  }\n\n  /**\n   * Register a builtin type (private, called during initialization).\n   */\n  private registerBuiltin(type: ResourceType): void {\n    this.handlers.set(type.name, type);\n    if (type.aliases) {\n      for (const alias of type.aliases) {\n        this.handlers.set(alias, type);\n      }\n    }\n  }\n\n  /**\n   * Register an extension type (public, for user-defined types).\n   * @throws ResourceTypeError if type is already registered\n   */\n  register(type: ResourceType): void {\n    if (this.handlers.has(type.name)) {\n      throw new ResourceTypeError(`Type '${type.name}' is already registered`);\n    }\n    this.handlers.set(type.name, type);\n    if (type.aliases) {\n      for (const alias of type.aliases) {\n        if (this.handlers.has(alias)) {\n          throw new ResourceTypeError(`Alias '${alias}' conflicts with existing type or alias`);\n        }\n        this.handlers.set(alias, type);\n      }\n    }\n  }\n\n  /**\n   * Check if a type is supported.\n   */\n  canHandle(typeName: string): boolean {\n    return this.handlers.has(typeName);\n  }\n\n  /**\n   * Get handler for a type.\n   */\n  getHandler(typeName: string): ResourceType | undefined {\n    return this.handlers.get(typeName);\n  }\n\n  /**\n   * Get all supported type names (including aliases).\n   */\n  getSupportedTypes(): string[] {\n    return Array.from(this.handlers.keys());\n  }\n\n  /**\n   * Serialize RXR content using the appropriate type handler.\n   * @throws ResourceTypeError if type is not supported\n   */\n  async serialize(rxr: RXR): Promise<Buffer> {\n    const typeName = rxr.manifest.type;\n    const handler = this.handlers.get(typeName);\n\n    if (!handler) {\n      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);\n    }\n\n    return handler.serializer.serialize(rxr);\n  }\n\n  /**\n   * Deserialize content into RXR using the appropriate type handler.\n   * @throws ResourceTypeError if type is not supported\n   */\n  async deserialize(data: Buffer, manifest: RXM): Promise<RXR> {\n    const typeName = manifest.type;\n    const handler = this.handlers.get(typeName);\n\n    if (!handler) {\n      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);\n    }\n\n    return handler.serializer.deserialize(data, manifest);\n  }\n\n  /**\n   * Resolve RXR content into usable object using the appropriate type handler.\n   * @throws ResourceTypeError if type is not supported\n   */\n  async resolve<T = unknown>(rxr: RXR): Promise<T> {\n    const typeName = rxr.manifest.type;\n    const handler = this.handlers.get(typeName);\n\n    if (!handler) {\n      throw new ResourceTypeError(`Unsupported resource type: ${typeName}`);\n    }\n\n    return handler.resolver.resolve(rxr) as Promise<T>;\n  }\n\n  /**\n   * Clear all extension types (for testing).\n   * Keeps builtin types intact.\n   */\n  clearExtensions(): void {\n    this.handlers.clear();\n    for (const type of builtinTypes) {\n      this.registerBuiltin(type);\n    }\n  }\n}\n\n/**\n * Global singleton instance of TypeHandlerChain.\n * All type registration and handling goes through this instance.\n */\nexport const globalTypeHandlerChain: TypeHandlerChain = TypeHandlerChain.getInstance();\n"
+  ],
+  "mappings": "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",
+  "debugId": "ED28E038CDB29DF864756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@resourcexjs/type",
+  "version": "1.0.0",
+  "description": "ResourceX Type System - Type handlers and serialization",
+  "keywords": [
+    "resourcex",
+    "resource",
+    "type",
+    "serialization"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Deepractice/ResourceX.git",
+    "directory": "packages/type"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun run build.ts",
+    "test": "bun test",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@resourcexjs/core": "^1.0.0"
+  },
+  "devDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}