@resourcexjs/type 2.2.0 → 2.4.0

package/dist/index.d.ts

@@ -1,16 +1,64 @@
-import { RXR, RXM } from "@resourcexjs/core";
 /**
-* ResourceSerializer - Handles RXR serialization/deserialization for storage.
+* Isolator type for resolver execution.
+* Matches SandboX isolator types directly.
+* Configured at Registry level, not per-type.
+*
+* - "none": No isolation, fastest (~10ms), for development
+* - "srt": OS-level isolation (~50ms), secure local dev
+* - "cloudflare": Container isolation (~100ms), local Docker or edge
+* - "e2b": MicroVM isolation (~150ms), production (planned)
 */
-interface ResourceSerializer {
+type IsolatorType = "none" | "srt" | "cloudflare" | "e2b";
+/**
+* ResolveContext - Pure data context passed to resolver in sandbox.
+*
+* This is a serializable data structure that replaces RXR for sandbox execution.
+* The executor pre-processes RXR (extracts files) before passing to resolver.
+*/
+interface ResolveContext {
 	/**
-	* Serialize RXR to storage format.
+	* Resource manifest metadata.
 	*/
-	serialize(rxr: RXR): Promise<Buffer>;
+	manifest: {
+		domain: string
+		path?: string
+		name: string
+		type: string
+		version: string
+	};
 	/**
-	* Deserialize storage data to RXR.
+	* Extracted files from archive.
+	* Key is file path, value is file content as Uint8Array.
 	*/
-	deserialize(data: Buffer, manifest: RXM): Promise<RXR>;
+	files: Record<string, Uint8Array>;
+}
+/**
+* BundledType - Pre-bundled resource type ready for execution.
+* Contains bundled code string instead of closure.
+*
+* Note: Sandbox isolation is configured at Registry level via createRegistry({ sandbox: ... })
+*/
+interface BundledType {
+	/**
+	* Type name (e.g., "text", "json", "prompt").
+	*/
+	name: string;
+	/**
+	* Alternative names for this type.
+	*/
+	aliases?: string[];
+	/**
+	* Human-readable description.
+	*/
+	description: string;
+	/**
+	* JSON Schema for resolver arguments.
+	*/
+	schema?: JSONSchema;
+	/**
+	* Bundled resolver code (executable in sandbox).
+	*/
+	code: string;
 }
 /**
 * JSON Schema property definition.
@@ -41,9 +89,9 @@ interface ResolvedResource<
 	TResult = unknown
 > {
 	/**
-	* Original RXR object (locator, manifest, content).
+	* Original resource object (RXR from @resourcexjs/core).
 	*/
-	resource: RXR;
+	resource: unknown;
 	/**
 	* Execute function to get the resource content.
 	* - For static resources (text/json/binary): call with no arguments
@@ -57,7 +105,7 @@ interface ResolvedResource<
 	schema: TArgs extends void ? undefined : JSONSchema;
 }
 /**
-* ResourceResolver - Transforms RXR into a structured result object.
+* ResourceResolver - Transforms resource into a structured result object.
 * The execute function is lazy-loaded: content is only read when called.
 */
 interface ResourceResolver<
@@ -70,9 +118,10 @@ interface ResourceResolver<
 	*/
 	schema: TArgs extends void ? undefined : JSONSchema;
 	/**
-	* Resolve RXR into a structured result object.
+	* Resolve resource into a structured result object.
+	* @param rxr - RXR object from @resourcexjs/core
 	*/
-	resolve(rxr: RXR): Promise<ResolvedResource<TArgs, TResult>>;
+	resolve(rxr: unknown): Promise<ResolvedResource<TArgs, TResult>>;
 }
 /**
 * ResourceType - Defines how a resource type is handled.
@@ -94,14 +143,23 @@ interface ResourceType<
 	*/
 	description: string;
 	/**
-	* Serializer for storage operations.
-	*/
-	serializer: ResourceSerializer;
-	/**
 	* Resolver to transform RXR into structured result object.
 	*/
 	resolver: ResourceResolver<TArgs, TResult>;
 }
+/**
+* Bundle a resource type from a source file.
+*
+* @param sourcePath - Path to the .type.ts file
+* @param basePath - Base path for resolving relative paths (defaults to cwd)
+* @returns BundledType ready for registry
+*
+* @example
+* ```typescript
+* const promptType = await bundleResourceType("./prompt.type.ts");
+* ```
+*/
+declare function bundleResourceType(sourcePath: string, basePath?: string): Promise<BundledType>;
 import { ResourceXError } from "@resourcexjs/core";
 /**
 * Resource type related error.
@@ -110,78 +168,69 @@ declare class ResourceTypeError extends ResourceXError {
 	constructor(message: string);
 }
 /**
-* Text resource type
-*/
-declare const textType: ResourceType<void, string>;
-/**
-* JSON resource type
-*/
-declare const jsonType: ResourceType<void, unknown>;
-/**
-* Binary resource type
-*/
-declare const binaryType: ResourceType<void, Buffer>;
-/**
-* All built-in types
-*/
-declare const builtinTypes: ResourceType<void, unknown>[];
-import { RXR as RXR2, RXM as RXM2 } from "@resourcexjs/core";
-/**
-* TypeHandlerChain - Manages type registration and delegates serialization/deserialization.
-* Use TypeHandlerChain.create() to create a new instance.
+* TypeHandlerChain - Manages resource type registration.
+*
+* Responsibilities:
+* - Register types (name + aliases)
+* - Look up types by name
+*
+* Execution is delegated to ResolverExecutor (in registry package).
+*
+* Built-in types (text, json, binary) are registered by default.
 */
 declare class TypeHandlerChain {
 	private handlers;
 	private constructor();
 	/**
 	* Create a new TypeHandlerChain instance.
-	* Each instance includes all builtin types (text, json, binary).
+	* Built-in types (text, json, binary) are included by default.
 	*/
 	static create(): TypeHandlerChain;
 	/**
-	* Register a builtin type (private, called during initialization).
+	* Internal registration (no duplicate check).
 	*/
-	private registerBuiltin;
+	private registerInternal;
 	/**
-	* Register an extension type (public, for user-defined types).
+	* Register a type.
 	* @throws ResourceTypeError if type is already registered
 	*/
-	register(type: ResourceType): void;
+	register(type: BundledType): 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>;
+	getHandler(typeName: string): BundledType;
 	/**
-	* Deserialize content into RXR using the appropriate type handler.
-	* @throws ResourceTypeError if type is not supported
+	* Get handler for a type, or undefined if not found.
 	*/
-	deserialize(data: Buffer, manifest: RXM2): Promise<RXR2>;
+	getHandlerOrUndefined(typeName: string): BundledType | undefined;
 	/**
-	* Resolve RXR content into structured result object using the appropriate type handler.
-	* Returns an object with execute function and optional schema.
-	* @throws ResourceTypeError if type is not supported
+	* Get all supported type names (including aliases).
 	*/
-	resolve<
-		TArgs = void,
-		TResult = unknown
-	>(rxr: RXR2): Promise<ResolvedResource<TArgs, TResult>>;
+	getSupportedTypes(): string[];
 	/**
-	* Clear all extension types (for testing).
-	* Keeps builtin types intact.
+	* Clear all registered types (for testing).
 	*/
-	clearExtensions(): void;
+	clear(): void;
 }
-export { textType, jsonType, builtinTypes, binaryType, TypeHandlerChain, ResourceTypeError, ResourceType, ResourceSerializer, ResourceResolver, ResolvedResource, JSONSchemaProperty, JSONSchema };
+/**
+* Plain text content
+*/
+declare const textType: BundledType;
+/**
+* JSON content
+*/
+declare const jsonType: BundledType;
+/**
+* Binary content
+*/
+declare const binaryType: BundledType;
+/**
+* All built-in types as an array.
+*/
+declare const builtinTypes: BundledType[];
+export { textType, jsonType, bundleResourceType, builtinTypes, binaryType, TypeHandlerChain, ResourceTypeError, ResourceType, ResourceResolver, ResolvedResource, ResolveContext, JSONSchemaProperty, JSONSchema, IsolatorType, BundledType };