@resourcexjs/core 0.0.1

package/README.md

@@ -0,0 +1,122 @@
+# @resourcexjs/core
+
+Core implementation of Agent Resource Protocol (ARP).
+
+> **Note**: For most use cases, use the [`resourcexjs`](https://www.npmjs.com/package/resourcexjs) package instead. This package is for advanced usage and custom extensions.
+
+## Installation
+
+```bash
+npm install @resourcexjs/core
+# or
+bun add @resourcexjs/core
+```
+
+## Usage
+
+### Parse ARP URLs
+
+```typescript
+import { parseARP } from "@resourcexjs/core";
+
+const parsed = parseARP("arp:text:https://example.com/file.txt");
+// { semantic: "text", transport: "https", location: "example.com/file.txt" }
+```
+
+### Resolve Resources
+
+```typescript
+import { resolve } from "@resourcexjs/core";
+
+const resource = await resolve("arp:text:https://example.com/file.txt");
+// { type: "text", content: "...", meta: { ... } }
+```
+
+### Custom Transport Handler
+
+```typescript
+import { registerTransportHandler, type TransportHandler } from "@resourcexjs/core";
+
+const s3Handler: TransportHandler = {
+  protocol: "s3",
+  async fetch(location: string): Promise<Buffer> {
+    // fetch from S3...
+    return buffer;
+  },
+};
+
+registerTransportHandler(s3Handler);
+```
+
+### Custom Semantic Handler
+
+```typescript
+import { registerSemanticHandler, type SemanticHandler, type Resource } from "@resourcexjs/core";
+
+const jsonHandler: SemanticHandler = {
+  type: "json",
+  parse(content: Buffer, context): Resource {
+    return {
+      type: "json",
+      content: JSON.parse(content.toString("utf-8")),
+      meta: {
+        /* ... */
+      },
+    };
+  },
+};
+
+registerSemanticHandler(jsonHandler);
+```
+
+## Exports
+
+### Functions
+
+- `parseARP(url)` - Parse ARP URL string
+- `resolve(url)` - Resolve ARP URL to resource
+- `getTransportHandler(protocol)` - Get registered transport handler
+- `registerTransportHandler(handler)` - Register custom transport
+- `getSemanticHandler(type)` - Get registered semantic handler
+- `registerSemanticHandler(handler)` - Register custom semantic
+
+### Built-in Handlers
+
+**Transport:**
+
+- `httpsHandler` - HTTPS protocol
+- `httpHandler` - HTTP protocol
+- `fileHandler` - Local file system
+
+**Semantic:**
+
+- `textHandler` - Plain text
+
+### Error Classes
+
+```typescript
+import {
+  ResourceXError, // Base error
+  ParseError, // ARP URL parsing failed
+  TransportError, // Transport layer failed
+  SemanticError, // Semantic layer failed
+} from "@resourcexjs/core";
+```
+
+### Types
+
+```typescript
+import type {
+  ParsedARP,
+  Resource,
+  ResourceMeta,
+  ParseContext,
+  TransportHandler,
+  SemanticHandler,
+  TextResource,
+} from "@resourcexjs/core";
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,156 @@
+/**
+* ResourceX Error Types
+*/
+/**
+* Base error class for all ResourceX errors
+*/
+declare class ResourceXError extends Error {
+	constructor(message: string, options?: ErrorOptions);
+}
+/**
+* Error thrown when ARP URL parsing fails
+*/
+declare class ParseError extends ResourceXError {
+	readonly url?: string;
+	constructor(message: string, url?: string);
+}
+/**
+* Error thrown when transport layer fails
+*/
+declare class TransportError extends ResourceXError {
+	readonly transport?: string;
+	constructor(message: string, transport?: string, options?: ErrorOptions);
+}
+/**
+* Error thrown when semantic layer fails
+*/
+declare class SemanticError extends ResourceXError {
+	readonly semantic?: string;
+	constructor(message: string, semantic?: string, options?: ErrorOptions);
+}
+interface ParsedARP {
+	semantic: string;
+	transport: string;
+	location: string;
+}
+/**
+* Parse an ARP URL into its components
+*
+* @example
+* parseARP("arp:text:https://example.com/file.txt")
+* // { semantic: "text", transport: "https", location: "example.com/file.txt" }
+*/
+declare function parseARP(url: string): ParsedARP;
+/**
+* Transport Handler Interface
+* Responsible for fetching resource content from various sources
+*/
+interface TransportHandler {
+	/**
+	* Transport type name (e.g., "https", "file")
+	*/
+	readonly type: string;
+	/**
+	* Fetch resource content from the given location
+	* @param location - The location string after ://
+	* @returns Raw content as Buffer
+	*/
+	fetch(location: string): Promise<Buffer>;
+}
+declare class HttpTransportHandler implements TransportHandler {
+	readonly type: string;
+	private readonly protocol;
+	constructor(protocol?: "http" | "https");
+	fetch(location: string): Promise<Buffer>;
+}
+declare const httpsHandler: HttpTransportHandler;
+declare const httpHandler: HttpTransportHandler;
+declare class FileTransportHandler implements TransportHandler {
+	readonly type = "file";
+	fetch(location: string): Promise<Buffer>;
+}
+declare const fileHandler: FileTransportHandler;
+/**
+* Get transport handler by type
+*/
+declare function getTransportHandler(type: string): TransportHandler;
+/**
+* Register a custom transport handler
+*/
+declare function registerTransportHandler(handler: TransportHandler): void;
+/**
+* Semantic Handler Interface
+* Responsible for parsing raw content into AI-usable format
+*/
+/**
+* Resource metadata
+*/
+interface ResourceMeta {
+	url: string;
+	semantic: string;
+	transport: string;
+	location: string;
+	size: number;
+	encoding?: string;
+	mimeType?: string;
+	fetchedAt: string;
+}
+/**
+* Context passed to semantic handler
+*/
+interface ParseContext {
+	url: string;
+	semantic: string;
+	transport: string;
+	location: string;
+	fetchedAt: Date;
+}
+/**
+* Base resource interface
+*/
+interface Resource<T = unknown> {
+	type: string;
+	content: T;
+	meta: ResourceMeta;
+}
+/**
+* Semantic handler interface
+*/
+interface SemanticHandler<T = unknown> {
+	readonly type: string;
+	/**
+	* Parse raw content into structured resource
+	*/
+	parse(content: Buffer, context: ParseContext): Resource<T>;
+}
+interface TextResource extends Resource<string> {
+	type: "text";
+	content: string;
+}
+declare class TextSemanticHandler implements SemanticHandler<string> {
+	readonly type = "text";
+	parse(content: Buffer, context: ParseContext): TextResource;
+}
+declare const textHandler: TextSemanticHandler;
+/**
+* Get semantic handler by type
+*/
+declare function getSemanticHandler(type: string): SemanticHandler;
+/**
+* Register a custom semantic handler
+*/
+declare function registerSemanticHandler(handler: SemanticHandler): void;
+/**
+* Resolve an ARP URL to a resource
+*
+* @example
+* const resource = await resolve("arp:text:https://example.com/file.txt");
+* // { type: "text", content: "...", meta: { ... } }
+*/
+declare function resolve(url: string): Promise<Resource>;
+/**
+* @resourcexjs/core
+* ARP (Agent Resource Protocol) implementation
+*/
+declare const VERSION = "0.0.1";
+export { textHandler, resolve, registerTransportHandler, registerSemanticHandler, parseARP, httpsHandler, httpHandler, getTransportHandler, getSemanticHandler, fileHandler, VERSION, TransportHandler, TransportError, TextResource, SemanticHandler, SemanticError, ResourceXError, ResourceMeta, Resource, ParsedARP, ParseError, ParseContext };

package/dist/index.js

@@ -0,0 +1,197 @@
+// src/errors.ts
+class ResourceXError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ResourceXError";
+  }
+}
+
+class ParseError extends ResourceXError {
+  url;
+  constructor(message, url) {
+    super(message);
+    this.url = url;
+    this.name = "ParseError";
+  }
+}
+
+class TransportError extends ResourceXError {
+  transport;
+  constructor(message, transport, options) {
+    super(message, options);
+    this.transport = transport;
+    this.name = "TransportError";
+  }
+}
+
+class SemanticError extends ResourceXError {
+  semantic;
+  constructor(message, semantic, options) {
+    super(message, options);
+    this.semantic = semantic;
+    this.name = "SemanticError";
+  }
+}
+// src/parser.ts
+function parseARP(url) {
+  if (!url.startsWith("arp:")) {
+    throw new ParseError(`Invalid ARP URL: must start with "arp:"`, url);
+  }
+  const content = url.substring(4);
+  const separatorIndex = content.indexOf("://");
+  if (separatorIndex === -1) {
+    throw new ParseError(`Invalid ARP URL: missing "://"`, url);
+  }
+  const typePart = content.substring(0, separatorIndex);
+  const location = content.substring(separatorIndex + 3);
+  const colonIndex = typePart.indexOf(":");
+  if (colonIndex === -1) {
+    throw new ParseError(`Invalid ARP URL: must have exactly 2 types (semantic:transport)`, url);
+  }
+  const semantic = typePart.substring(0, colonIndex);
+  const transport = typePart.substring(colonIndex + 1);
+  if (!semantic) {
+    throw new ParseError(`Invalid ARP URL: semantic type cannot be empty`, url);
+  }
+  if (!transport) {
+    throw new ParseError(`Invalid ARP URL: transport type cannot be empty`, url);
+  }
+  if (!location) {
+    throw new ParseError(`Invalid ARP URL: location cannot be empty`, url);
+  }
+  return { semantic, transport, location };
+}
+// src/transport/http.ts
+class HttpTransportHandler {
+  type;
+  protocol;
+  constructor(protocol = "https") {
+    this.protocol = protocol;
+    this.type = protocol;
+  }
+  async fetch(location) {
+    const url = `${this.protocol}://${location}`;
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new TransportError(`HTTP ${response.status}: ${response.statusText} - ${url}`, this.type);
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } catch (error) {
+      if (error instanceof TransportError) {
+        throw error;
+      }
+      throw new TransportError(`Network error: ${url}`, this.type, { cause: error });
+    }
+  }
+}
+var httpsHandler = new HttpTransportHandler("https");
+var httpHandler = new HttpTransportHandler("http");
+// src/transport/file.ts
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+class FileTransportHandler {
+  type = "file";
+  async fetch(location) {
+    const filePath = resolve(process.cwd(), location);
+    try {
+      return await readFile(filePath);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.type, {
+        cause: err
+      });
+    }
+  }
+}
+var fileHandler = new FileTransportHandler;
+// src/transport/index.ts
+var handlers = new Map([
+  ["https", httpsHandler],
+  ["http", httpHandler],
+  ["file", fileHandler]
+]);
+function getTransportHandler(type) {
+  const handler = handlers.get(type);
+  if (!handler) {
+    throw new TransportError(`Unsupported transport type: ${type}`, type);
+  }
+  return handler;
+}
+function registerTransportHandler(handler) {
+  handlers.set(handler.type, handler);
+}
+// src/semantic/text.ts
+class TextSemanticHandler {
+  type = "text";
+  parse(content, context) {
+    const text = content.toString("utf-8");
+    const meta = {
+      url: context.url,
+      semantic: context.semantic,
+      transport: context.transport,
+      location: context.location,
+      size: content.length,
+      encoding: "utf-8",
+      mimeType: "text/plain",
+      fetchedAt: context.fetchedAt.toISOString()
+    };
+    return {
+      type: "text",
+      content: text,
+      meta
+    };
+  }
+}
+var textHandler = new TextSemanticHandler;
+// src/semantic/index.ts
+var handlers2 = new Map([["text", textHandler]]);
+function getSemanticHandler(type) {
+  const handler = handlers2.get(type);
+  if (!handler) {
+    throw new SemanticError(`Unsupported semantic type: ${type}`, type);
+  }
+  return handler;
+}
+function registerSemanticHandler(handler) {
+  handlers2.set(handler.type, handler);
+}
+// src/resolve.ts
+async function resolve2(url) {
+  const fetchedAt = new Date;
+  const parsed = parseARP(url);
+  const transportHandler = getTransportHandler(parsed.transport);
+  const semanticHandler = getSemanticHandler(parsed.semantic);
+  const content = await transportHandler.fetch(parsed.location);
+  const context = {
+    url,
+    semantic: parsed.semantic,
+    transport: parsed.transport,
+    location: parsed.location,
+    fetchedAt
+  };
+  return semanticHandler.parse(content, context);
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+export {
+  textHandler,
+  resolve2 as resolve,
+  registerTransportHandler,
+  registerSemanticHandler,
+  parseARP,
+  httpsHandler,
+  httpHandler,
+  getTransportHandler,
+  getSemanticHandler,
+  fileHandler,
+  VERSION,
+  TransportError,
+  SemanticError,
+  ResourceXError,
+  ParseError
+};
+
+//# debugId=7FDB8A773330183C64756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,18 @@
+{
+  "version": 3,
+  "sources": ["../src/errors.ts", "../src/parser.ts", "../src/transport/http.ts", "../src/transport/file.ts", "../src/transport/index.ts", "../src/semantic/text.ts", "../src/semantic/index.ts", "../src/resolve.ts", "../src/index.ts"],
+  "sourcesContent": [
+    "/**\n * ResourceX Error Types\n */\n\n/**\n * Base error class for all ResourceX errors\n */\nexport class ResourceXError extends Error {\n  constructor(message: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = \"ResourceXError\";\n  }\n}\n\n/**\n * Error thrown when ARP URL parsing fails\n */\nexport class ParseError extends ResourceXError {\n  constructor(\n    message: string,\n    public readonly url?: string\n  ) {\n    super(message);\n    this.name = \"ParseError\";\n  }\n}\n\n/**\n * Error thrown when transport layer fails\n */\nexport class TransportError extends ResourceXError {\n  constructor(\n    message: string,\n    public readonly transport?: string,\n    options?: ErrorOptions\n  ) {\n    super(message, options);\n    this.name = \"TransportError\";\n  }\n}\n\n/**\n * Error thrown when semantic layer fails\n */\nexport class SemanticError extends ResourceXError {\n  constructor(\n    message: string,\n    public readonly semantic?: string,\n    options?: ErrorOptions\n  ) {\n    super(message, options);\n    this.name = \"SemanticError\";\n  }\n}\n",
+    "/**\n * ARP URL Parser\n * Format: arp:{semantic}:{transport}://{location}\n */\n\nimport { ParseError } from \"./errors.js\";\n\nexport interface ParsedARP {\n  semantic: string;\n  transport: string;\n  location: string;\n}\n\n/**\n * Parse an ARP URL into its components\n *\n * @example\n * parseARP(\"arp:text:https://example.com/file.txt\")\n * // { semantic: \"text\", transport: \"https\", location: \"example.com/file.txt\" }\n */\nexport function parseARP(url: string): ParsedARP {\n  // 1. Check protocol prefix\n  if (!url.startsWith(\"arp:\")) {\n    throw new ParseError(`Invalid ARP URL: must start with \"arp:\"`, url);\n  }\n\n  const content = url.substring(4); // Remove \"arp:\"\n\n  // 2. Find :// separator\n  const separatorIndex = content.indexOf(\"://\");\n  if (separatorIndex === -1) {\n    throw new ParseError(`Invalid ARP URL: missing \"://\"`, url);\n  }\n\n  const typePart = content.substring(0, separatorIndex);\n  const location = content.substring(separatorIndex + 3);\n\n  // 3. Split type part by :\n  const colonIndex = typePart.indexOf(\":\");\n  if (colonIndex === -1) {\n    throw new ParseError(`Invalid ARP URL: must have exactly 2 types (semantic:transport)`, url);\n  }\n\n  const semantic = typePart.substring(0, colonIndex);\n  const transport = typePart.substring(colonIndex + 1);\n\n  // 4. Validate non-empty\n  if (!semantic) {\n    throw new ParseError(`Invalid ARP URL: semantic type cannot be empty`, url);\n  }\n  if (!transport) {\n    throw new ParseError(`Invalid ARP URL: transport type cannot be empty`, url);\n  }\n  if (!location) {\n    throw new ParseError(`Invalid ARP URL: location cannot be empty`, url);\n  }\n\n  return { semantic, transport, location };\n}\n",
+    "/**\n * HTTP/HTTPS Transport Handler\n */\n\nimport { TransportError } from \"../errors.js\";\nimport type { TransportHandler } from \"./types.js\";\n\nexport class HttpTransportHandler implements TransportHandler {\n  readonly type: string;\n  private readonly protocol: \"http\" | \"https\";\n\n  constructor(protocol: \"http\" | \"https\" = \"https\") {\n    this.protocol = protocol;\n    this.type = protocol;\n  }\n\n  async fetch(location: string): Promise<Buffer> {\n    const url = `${this.protocol}://${location}`;\n\n    try {\n      const response = await fetch(url);\n\n      if (!response.ok) {\n        throw new TransportError(\n          `HTTP ${response.status}: ${response.statusText} - ${url}`,\n          this.type\n        );\n      }\n\n      const arrayBuffer = await response.arrayBuffer();\n      return Buffer.from(arrayBuffer);\n    } catch (error) {\n      if (error instanceof TransportError) {\n        throw error;\n      }\n      throw new TransportError(`Network error: ${url}`, this.type, { cause: error as Error });\n    }\n  }\n}\n\nexport const httpsHandler: HttpTransportHandler = new HttpTransportHandler(\"https\");\nexport const httpHandler: HttpTransportHandler = new HttpTransportHandler(\"http\");\n",
+    "/**\n * File Transport Handler\n */\n\nimport { readFile } from \"node:fs/promises\";\nimport { resolve } from \"node:path\";\nimport { TransportError } from \"../errors.js\";\nimport type { TransportHandler } from \"./types.js\";\n\nexport class FileTransportHandler implements TransportHandler {\n  readonly type = \"file\";\n\n  async fetch(location: string): Promise<Buffer> {\n    const filePath = resolve(process.cwd(), location);\n\n    try {\n      return await readFile(filePath);\n    } catch (error) {\n      const err = error as Error & { code?: string };\n      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.type, {\n        cause: err,\n      });\n    }\n  }\n}\n\nexport const fileHandler: FileTransportHandler = new FileTransportHandler();\n",
+    "/**\n * Transport Handlers Registry\n */\n\nimport { TransportError } from \"../errors.js\";\n\nexport type { TransportHandler } from \"./types.js\";\nexport { HttpTransportHandler, httpsHandler, httpHandler } from \"./http.js\";\nexport { FileTransportHandler, fileHandler } from \"./file.js\";\n\nimport type { TransportHandler } from \"./types.js\";\nimport { httpsHandler, httpHandler } from \"./http.js\";\nimport { fileHandler } from \"./file.js\";\n\nconst handlers = new Map<string, TransportHandler>([\n  [\"https\", httpsHandler],\n  [\"http\", httpHandler],\n  [\"file\", fileHandler],\n]);\n\n/**\n * Get transport handler by type\n */\nexport function getTransportHandler(type: string): TransportHandler {\n  const handler = handlers.get(type);\n  if (!handler) {\n    throw new TransportError(`Unsupported transport type: ${type}`, type);\n  }\n  return handler;\n}\n\n/**\n * Register a custom transport handler\n */\nexport function registerTransportHandler(handler: TransportHandler): void {\n  handlers.set(handler.type, handler);\n}\n",
+    "/**\n * Text Semantic Handler\n * Handles plain text resources\n */\n\nimport type { Resource, SemanticHandler, ParseContext, ResourceMeta } from \"./types.js\";\n\nexport interface TextResource extends Resource<string> {\n  type: \"text\";\n  content: string;\n}\n\nexport class TextSemanticHandler implements SemanticHandler<string> {\n  readonly type = \"text\";\n\n  parse(content: Buffer, context: ParseContext): TextResource {\n    const text = content.toString(\"utf-8\");\n\n    const meta: ResourceMeta = {\n      url: context.url,\n      semantic: context.semantic,\n      transport: context.transport,\n      location: context.location,\n      size: content.length,\n      encoding: \"utf-8\",\n      mimeType: \"text/plain\",\n      fetchedAt: context.fetchedAt.toISOString(),\n    };\n\n    return {\n      type: \"text\",\n      content: text,\n      meta,\n    };\n  }\n}\n\nexport const textHandler: TextSemanticHandler = new TextSemanticHandler();\n",
+    "/**\n * Semantic Handlers Registry\n */\n\nimport { SemanticError } from \"../errors.js\";\n\nexport type { Resource, SemanticHandler, ResourceMeta, ParseContext } from \"./types.js\";\nexport type { TextResource } from \"./text.js\";\nexport { TextSemanticHandler, textHandler } from \"./text.js\";\n\nimport type { SemanticHandler } from \"./types.js\";\nimport { textHandler } from \"./text.js\";\n\nconst handlers: Map<string, SemanticHandler> = new Map([[\"text\", textHandler]]);\n\n/**\n * Get semantic handler by type\n */\nexport function getSemanticHandler(type: string): SemanticHandler {\n  const handler = handlers.get(type);\n  if (!handler) {\n    throw new SemanticError(`Unsupported semantic type: ${type}`, type);\n  }\n  return handler;\n}\n\n/**\n * Register a custom semantic handler\n */\nexport function registerSemanticHandler(handler: SemanticHandler): void {\n  handlers.set(handler.type, handler);\n}\n",
+    "/**\n * Resource Resolution\n * End-to-end flow: URL parse → Transport fetch → Semantic parse\n */\n\nimport { parseARP } from \"./parser.js\";\nimport { getTransportHandler } from \"./transport/index.js\";\nimport { getSemanticHandler, type Resource, type ParseContext } from \"./semantic/index.js\";\n\n/**\n * Resolve an ARP URL to a resource\n *\n * @example\n * const resource = await resolve(\"arp:text:https://example.com/file.txt\");\n * // { type: \"text\", content: \"...\", meta: { ... } }\n */\nexport async function resolve(url: string): Promise<Resource> {\n  const fetchedAt = new Date();\n\n  // 1. Parse URL\n  const parsed = parseARP(url);\n\n  // 2. Get handlers\n  const transportHandler = getTransportHandler(parsed.transport);\n  const semanticHandler = getSemanticHandler(parsed.semantic);\n\n  // 3. Fetch raw content\n  const content = await transportHandler.fetch(parsed.location);\n\n  // 4. Build context for semantic handler\n  const context: ParseContext = {\n    url,\n    semantic: parsed.semantic,\n    transport: parsed.transport,\n    location: parsed.location,\n    fetchedAt,\n  };\n\n  // 5. Parse and return\n  return semanticHandler.parse(content, context);\n}\n",
+    "/**\n * @resourcexjs/core\n * ARP (Agent Resource Protocol) implementation\n */\n\nexport const VERSION = \"0.0.1\";\n\n// Errors\nexport { ResourceXError, ParseError, TransportError, SemanticError } from \"./errors.js\";\n\n// Parser\nexport { parseARP, type ParsedARP } from \"./parser.js\";\n\n// Transport\nexport {\n  type TransportHandler,\n  getTransportHandler,\n  registerTransportHandler,\n  httpsHandler,\n  httpHandler,\n  fileHandler,\n} from \"./transport/index.js\";\n\n// Semantic\nexport {\n  type Resource,\n  type SemanticHandler,\n  type ResourceMeta,\n  type ParseContext,\n  type TextResource,\n  getSemanticHandler,\n  registerSemanticHandler,\n  textHandler,\n} from \"./semantic/index.js\";\n\n// Resolve\nexport { resolve } from \"./resolve.js\";\n"
+  ],
+  "mappings": "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",
+  "debugId": "7FDB8A773330183C64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@resourcexjs/core",
+  "version": "0.0.1",
+  "description": "ResourceX Core - ARP (Agent Resource Protocol) implementation",
+  "keywords": [
+    "resourcex",
+    "arp",
+    "agent",
+    "resource",
+    "protocol"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Deepractice/ResourceX.git",
+    "directory": "packages/core"
+  },
+  "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",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}