@irpclib/irpc 0.0.1

package/dist/batch.d.ts

@@ -0,0 +1,18 @@
+import { IRPCCall } from "./call.js";
+
+//#region src/batch.d.ts
+
+/**
+ * Batches multiple IRPC calls together and executes them with a specified delay.
+ *
+ * This function collects IRPC calls in a queue and executes them all at once after
+ * a specified delay has passed. If multiple calls are made within the delay period,
+ * they will be grouped together in a single batch execution.
+ *
+ * @param call - The IRPC call to be added to the current batch
+ * @param handler - A function that will be called with all queued calls when the batch executes
+ * @param delay - The delay in milliseconds before executing the batch (default: 0)
+ */
+declare function batch(call: IRPCCall, handler: (calls: IRPCCall[]) => void, delay?: number): void;
+//#endregion
+export { batch };

package/dist/batch.js

@@ -0,0 +1,23 @@
+//#region src/batch.ts
+const IRPC_QUEUE = /* @__PURE__ */ new Set();
+/**
+* Batches multiple IRPC calls together and executes them with a specified delay.
+*
+* This function collects IRPC calls in a queue and executes them all at once after
+* a specified delay has passed. If multiple calls are made within the delay period,
+* they will be grouped together in a single batch execution.
+*
+* @param call - The IRPC call to be added to the current batch
+* @param handler - A function that will be called with all queued calls when the batch executes
+* @param delay - The delay in milliseconds before executing the batch (default: 0)
+*/
+function batch(call, handler, delay = 0) {
+	if (!IRPC_QUEUE.size) setTimeout(() => {
+		handler([...IRPC_QUEUE.values()]);
+		IRPC_QUEUE.clear();
+	}, delay);
+	IRPC_QUEUE.add(call);
+}
+
+//#endregion
+export { batch };

package/dist/call.d.ts

@@ -0,0 +1,43 @@
+import { IRPCPayload } from "./types.js";
+
+//#region src/call.d.ts
+
+/**
+ * Represents an RPC call with promise-like behavior for handling asynchronous operations.
+ * Each call has a unique identifier and manages its own resolution state.
+ */
+declare class IRPCCall {
+  payload: IRPCPayload;
+  resolver: (value: unknown) => void;
+  rejector: (reason?: Error) => void;
+  /**
+   * Unique identifier for this RPC call, generated using shortId().
+   */
+  id: string;
+  /**
+   * Flag indicating whether this call has been resolved or rejected.
+   * Prevents multiple resolutions of the same call.
+   */
+  resolved: boolean;
+  /**
+   * Creates a new IRPCCall instance.
+   * @param payload - The RPC payload containing method and parameters
+   * @param resolver - Function to resolve the associated promise with a value
+   * @param rejector - Function to reject the associated promise with an error
+   */
+  constructor(payload: IRPCPayload, resolver: (value: unknown) => void, rejector: (reason?: Error) => void);
+  /**
+   * Resolves the RPC call with the provided value.
+   * If the call is already resolved, this method does nothing.
+   * @param value - The value to resolve the promise with
+   */
+  resolve(value: unknown): void;
+  /**
+   * Rejects the RPC call with the provided reason.
+   * If the call is already resolved, this method does nothing.
+   * @param reason - Optional error reason for rejecting the promise
+   */
+  reject(reason?: Error): void;
+}
+//#endregion
+export { IRPCCall };

package/dist/call.js

@@ -0,0 +1,52 @@
+import { shortId } from "./utils.js";
+
+//#region src/call.ts
+/**
+* Represents an RPC call with promise-like behavior for handling asynchronous operations.
+* Each call has a unique identifier and manages its own resolution state.
+*/
+var IRPCCall = class {
+	/**
+	* Unique identifier for this RPC call, generated using shortId().
+	*/
+	id = shortId();
+	/**
+	* Flag indicating whether this call has been resolved or rejected.
+	* Prevents multiple resolutions of the same call.
+	*/
+	resolved = false;
+	/**
+	* Creates a new IRPCCall instance.
+	* @param payload - The RPC payload containing method and parameters
+	* @param resolver - Function to resolve the associated promise with a value
+	* @param rejector - Function to reject the associated promise with an error
+	*/
+	constructor(payload, resolver, rejector) {
+		this.payload = payload;
+		this.resolver = resolver;
+		this.rejector = rejector;
+	}
+	/**
+	* Resolves the RPC call with the provided value.
+	* If the call is already resolved, this method does nothing.
+	* @param value - The value to resolve the promise with
+	*/
+	resolve(value) {
+		if (this.resolved) return;
+		this.resolved = true;
+		this.resolver(value);
+	}
+	/**
+	* Rejects the RPC call with the provided reason.
+	* If the call is already resolved, this method does nothing.
+	* @param reason - Optional error reason for rejecting the promise
+	*/
+	reject(reason) {
+		if (this.resolved) return;
+		this.resolved = true;
+		this.rejector(reason);
+	}
+};
+
+//#endregion
+export { IRPCCall };

package/dist/context.d.ts

@@ -0,0 +1,40 @@
+import { IRPCContext, IRPCContextProvider } from "./types.js";
+
+//#region src/context.d.ts
+
+/**
+ * Sets the global context store for the IRPC system.
+ * This store is used to manage context data across requests.
+ * @param store - The context store implementation to use
+ */
+declare function setContextProvider(store: IRPCContextProvider): void;
+/**
+ * Executes a function with the provided context.
+ * If a context store is available, it runs the function within that context.
+ * Otherwise, it executes the function directly.
+ * @param ctx - The context to run the function with
+ * @param fn - The function to execute
+ * @returns The result of the executed function
+ */
+declare function withContext<R>(ctx: IRPCContext<string, unknown>, fn: () => R): R;
+/**
+ * Creates a new context map with optional initial values.
+ * @param init - Optional initial key-value pairs for the context
+ * @returns A new Map instance representing the context
+ */
+declare function createContext<K extends string, V>(init?: [K, V][]): Map<K, V>;
+/**
+ * Sets a value in the current context.
+ * @param key - The key to set in the context
+ * @param value - The value to associate with the key
+ */
+declare function setContext<V, K extends string = string>(key: K, value: V): void;
+/**
+ * Gets a value from the current context.
+ * @param key - The key to retrieve from the context
+ * @param fallback - Optional fallback value if the key is not found
+ * @returns The value associated with the key, or the fallback value if not found
+ */
+declare function getContext<V, K extends string = string>(key: K, fallback?: V): V | undefined;
+//#endregion
+export { createContext, getContext, setContext, setContextProvider, withContext };

package/dist/context.js

@@ -0,0 +1,51 @@
+//#region src/context.ts
+let currentStore;
+/**
+* Sets the global context store for the IRPC system.
+* This store is used to manage context data across requests.
+* @param store - The context store implementation to use
+*/
+function setContextProvider(store) {
+	currentStore = store;
+}
+/**
+* Executes a function with the provided context.
+* If a context store is available, it runs the function within that context.
+* Otherwise, it executes the function directly.
+* @param ctx - The context to run the function with
+* @param fn - The function to execute
+* @returns The result of the executed function
+*/
+function withContext(ctx, fn) {
+	return currentStore?.run(ctx, fn) ?? fn();
+}
+/**
+* Creates a new context map with optional initial values.
+* @param init - Optional initial key-value pairs for the context
+* @returns A new Map instance representing the context
+*/
+function createContext(init) {
+	return new Map(init);
+}
+/**
+* Sets a value in the current context.
+* @param key - The key to set in the context
+* @param value - The value to associate with the key
+*/
+function setContext(key, value) {
+	(currentStore?.getStore())?.set(key, value);
+}
+/**
+* Gets a value from the current context.
+* @param key - The key to retrieve from the context
+* @param fallback - Optional fallback value if the key is not found
+* @returns The value associated with the key, or the fallback value if not found
+*/
+function getContext(key, fallback) {
+	const result = (currentStore?.getStore())?.get(key);
+	if (typeof result === "undefined" && typeof fallback !== "undefined") return fallback;
+	return result;
+}
+
+//#endregion
+export { createContext, getContext, setContext, setContextProvider, withContext };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { IRPCArraySchema, IRPCAuthorizer, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCFactory, IRPCHandler, IRPCHost, IRPCInputs, IRPCModule, IRPCNamespace, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRegistry, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCStore, IRPCTransport } from "./types.js";
+import { IRPCCall } from "./call.js";
+import { batch } from "./batch.js";
+import { createContext, getContext, setContext, setContextProvider, withContext } from "./context.js";
+import { createModule } from "./module.js";
+import { shortId } from "./utils.js";
+export { IRPCArraySchema, IRPCAuthorizer, IRPCCall, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCFactory, IRPCHandler, IRPCHost, IRPCInputs, IRPCModule, IRPCNamespace, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRegistry, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCStore, IRPCTransport, batch, createContext, createModule, getContext, setContext, setContextProvider, shortId, withContext };

package/dist/index.js

@@ -0,0 +1,8 @@
+import { batch } from "./batch.js";
+import { shortId } from "./utils.js";
+import { IRPCCall } from "./call.js";
+import { createContext, getContext, setContext, setContextProvider, withContext } from "./context.js";
+import { IRPCTransport } from "./types.js";
+import { createModule } from "./module.js";
+
+export { IRPCCall, IRPCTransport, batch, createContext, createModule, getContext, setContext, setContextProvider, shortId, withContext };

package/dist/module.d.ts

@@ -0,0 +1,17 @@
+import { IRPCFactory, IRPCModule } from "./types.js";
+
+//#region src/module.d.ts
+
+/**
+ * Creates an IRPC module with the given configuration.
+ *
+ * This function initializes a new IRPC module with a store for tracking RPC calls,
+ * a registry for mapping functions to their specifications, and various methods
+ * for managing and executing remote procedure calls.
+ *
+ * @param config - Optional partial configuration for the IRPC module, excluding 'submit' and 'transport'
+ * @returns An IRPC factory function with attached utility methods
+ */
+declare function createModule(config?: Partial<Omit<IRPCModule, 'submit' | 'transport'>>): IRPCFactory;
+//#endregion
+export { createModule };

package/dist/module.js

@@ -0,0 +1,156 @@
+import { batch } from "./batch.js";
+import { IRPCCall } from "./call.js";
+
+//#region src/module.ts
+const DEFAULT_TIMEOUT = 2e4;
+/**
+* Creates an IRPC module with the given configuration.
+*
+* This function initializes a new IRPC module with a store for tracking RPC calls,
+* a registry for mapping functions to their specifications, and various methods
+* for managing and executing remote procedure calls.
+*
+* @param config - Optional partial configuration for the IRPC module, excluding 'submit' and 'transport'
+* @returns An IRPC factory function with attached utility methods
+*/
+function createModule(config) {
+	const store = /* @__PURE__ */ new Map();
+	const registry = /* @__PURE__ */ new WeakMap();
+	const module = {
+		name: "irpc",
+		version: "1.0.0",
+		timeout: DEFAULT_TIMEOUT,
+		...config
+	};
+	/**
+	* Factory function that creates IRPC handlers based on specifications.
+	* Each handler can either execute a local function or make a remote call.
+	*/
+	const factory = ((spec) => {
+		const host = { ...spec };
+		store.set(host.name, host);
+		const fn = ((...args) => {
+			if (typeof host.handler === "function") return host.handler(...args);
+			else return remoteCall(module, host, ...args);
+		});
+		registry.set(fn, host);
+		return fn;
+	});
+	/**
+	* Returns the namespace information of the module (name and version).
+	*/
+	Object.defineProperty(factory, "namespace", { get: () => ({
+		name: module.name,
+		version: module.version
+	}) });
+	/**
+	* Associates a handler function with an IRPC specification.
+	* @param irpc - The IRPC function to construct
+	* @param handler - The actual implementation of the IRPC function
+	*/
+	factory.construct = ((irpc, handler) => {
+		if (typeof irpc !== "function") throw new Error("Invalid IRPC.");
+		const host = registry.get(irpc);
+		if (!host) throw new Error("IRPC can not be found.");
+		host.handler = handler;
+	});
+	/**
+	* Sets the transport mechanism for the module.
+	* @param transport - The transport layer to use for remote calls
+	*/
+	factory.use = ((transport) => {
+		if (typeof transport?.send !== "function") throw new Error("Invalid transport.");
+		module.transport = transport;
+	});
+	/**
+	* Retrieves an IRPC specification by name.
+	* @param name - The name of the IRPC to retrieve
+	* @returns The IRPC specification or undefined if not found
+	*/
+	factory.get = ((name) => {
+		return store.get(name);
+	});
+	/**
+	* Updates the module configuration.
+	* @param config - Configuration properties to update
+	*/
+	factory.configure = ((config$1) => {
+		Object.assign(module, { ...config$1 });
+	});
+	/**
+	* Retrieves information about an IRPC by its request details.
+	* @param req - Request containing the name of the IRPC to look up
+	* @returns The IRPC specification or undefined if not found
+	*/
+	factory.info = ((req) => {
+		return store.get(req.name);
+	});
+	/**
+	* Resolves and executes an IRPC call with the provided arguments.
+	* @param req - Request containing the name and arguments for the IRPC call
+	* @returns The result of executing the IRPC handler
+	*/
+	factory.resolve = ((req) => {
+		const host = store.get(req.name);
+		if (!host) throw new Error("IRPC can not be found.");
+		if (!host.handler) throw new Error("IRPC handler can not be found.");
+		return host.handler(...req.args);
+	});
+	/**
+	* Submits a batch of IRPC calls for execution via the transport layer.
+	* @param calls - Array of IRPC calls to submit
+	*/
+	module.submit = ((calls) => {
+		try {
+			const promise = module.transport.send(calls);
+			if (promise instanceof Promise) promise.catch((reason) => {
+				calls.forEach((call) => {
+					call.reject(reason);
+				});
+			});
+		} catch (error) {
+			calls.forEach((call) => {
+				call.reject(error);
+			});
+		}
+	});
+	return factory;
+}
+/**
+* Executes a remote procedure call through the configured transport layer.
+*
+* This function creates an IRPC call payload and sends it through the module's transport mechanism.
+* It handles timeouts and promise resolution/rejection based on the response.
+*
+* @param module - The IRPC module containing transport and configuration
+* @param spec - The IRPC specification defining the remote procedure
+* @param args - Arguments to pass to the remote procedure
+* @returns A promise that resolves with the remote call result or rejects with an error
+* @throws Error if no transport is configured or if the call times out
+*/
+function remoteCall(module, spec, ...args) {
+	const payload = {
+		name: spec.name,
+		args
+	};
+	return new Promise((resolve, reject) => {
+		if (!module.transport) {
+			reject(/* @__PURE__ */ new Error("IRPC transport can not be found."));
+			return;
+		}
+		const timeout = module.timeout ? setTimeout(() => {
+			call.reject(/* @__PURE__ */ new Error("IRPC timeout."));
+		}, module.timeout) : void 0;
+		const call = new IRPCCall(payload, (value) => {
+			resolve(value);
+			clearTimeout(timeout);
+		}, (reason) => {
+			reject(reason);
+			clearTimeout(timeout);
+		});
+		batch(call, module.submit);
+	});
+}
+
+//#endregion
+export { createModule };

package/dist/types.d.ts

@@ -0,0 +1,224 @@
+import { IRPCCall } from "./call.js";
+import { ZodArray, ZodBoolean, ZodNull, ZodNumber, ZodObject, ZodSafeParseResult, ZodString, ZodUndefined } from "zod/v4";
+
+//#region src/types.d.ts
+
+/**
+ * A registry that maps IRPCHandlers to their corresponding IRPCHosts.
+ * Uses WeakMap to avoid memory leaks by not preventing garbage collection of handlers.
+ */
+type IRPCRegistry = WeakMap<IRPCHandler, IRPCHost<IRPCInputs, IRPCOutput>>;
+/**
+ * A store that maps string identifiers to IRPCHosts.
+ * Used to keep track of available RPC hosts by their names.
+ */
+type IRPCStore = Map<string, IRPCHost<IRPCInputs, IRPCOutput>>;
+/**
+ * A function that authorizes RPC requests.
+ * Takes a Request object and returns a boolean (sync or async) indicating authorization status.
+ */
+type IRPCAuthorizer = (req: Request) => Promise<boolean> | boolean;
+/**
+ * Represents primitive data types that can be used in IRPC communications.
+ * Includes string, number, boolean, null, and undefined.
+ */
+type IRPCPrimitive = string | number | boolean | null | undefined;
+/**
+ * Represents an object structure where keys are strings and values are IRPCData.
+ * Used for structured data in RPC communications.
+ */
+type IRPCObject = {
+  [key: string]: IRPCData;
+};
+/**
+ * Represents all possible data types in IRPC, including primitives, objects, and arrays.
+ * This is a recursive type that allows nested structures.
+ */
+type IRPCData = IRPCPrimitive | IRPCObject | IRPCData[];
+/**
+ * Union type of all primitive Zod schema types used for validation.
+ */
+type IRPCPrimitiveSchema = ZodString | ZodNumber | ZodBoolean | ZodNull | ZodUndefined;
+/**
+ * Zod object schema type used for validating structured data.
+ */
+type IRPCObjectSchema = ZodObject;
+/**
+ * Zod array schema that can contain primitive schemas or object schemas.
+ */
+type IRPCArraySchema = ZodArray<IRPCPrimitiveSchema | IRPCObjectSchema>;
+/**
+ * Union type of all possible Zod schema types used in IRPC for input/output validation.
+ */
+type IRPCDataSchema = IRPCPrimitiveSchema | IRPCObjectSchema | IRPCArraySchema;
+/**
+ * Type representing the result of a Zod schema validation operation.
+ */
+type IRPCParseResult = ZodSafeParseResult<IRPCDataSchema>;
+/**
+ * Represents an array of input schemas for an RPC function.
+ */
+type IRPCInputs = IRPCDataSchema[];
+/**
+ * Represents the output schema for an RPC function.
+ */
+type IRPCOutput = IRPCDataSchema;
+/**
+ * Defines the basic information about an RPC namespace.
+ */
+type IRPCNamespace = {
+  /** The name of the namespace */
+  name: string;
+  /** The version of the namespace */
+  version: string;
+  /** Optional description of the namespace */
+  description?: string;
+};
+/**
+ * Defines an RPC module which extends a namespace with execution capabilities.
+ */
+type IRPCModule = IRPCNamespace & {
+  /** Optional function to submit RPC calls */
+  submit?: (calls: IRPCCall[]) => Promise<IRPCResponse[]>;
+  /** Optional timeout for RPC calls */
+  timeout?: number;
+  /** Optional transport mechanism for RPC communications */
+  transport?: IRPCTransport;
+};
+/**
+ * Represents the payload of an RPC call with its name and arguments.
+ */
+type IRPCPayload = {
+  /** The name of the RPC function to call */
+  name: string;
+  /** The arguments to pass to the RPC function */
+  args: IRPCData[];
+};
+/**
+ * Defines the schema for input and output validation of an RPC function.
+ */
+type IRPCSchema<I extends IRPCInputs, O extends IRPCOutput> = {
+  /** Optional input validation schemas */
+  input?: I;
+  /** Optional output validation schema */
+  output?: O;
+};
+/**
+ * Type definition for an RPC handler function.
+ * Takes IRPCData arguments and returns a Promise resolving to IRPCData.
+ */
+type IRPCHandler = (...args: IRPCData[]) => Promise<IRPCData>;
+/**
+ * Specification for an RPC function including its name, schema, and description.
+ */
+type IRPCSpec<I extends IRPCInputs, O extends IRPCOutput> = {
+  /** The name of the RPC function */
+  name: string;
+  /** Optional schema for input/output validation */
+  schema?: IRPCSchema<I, O>;
+  /** Optional description of the RPC function */
+  description?: string;
+};
+/**
+ * Host definition for an RPC function that combines the specification with execution details.
+ */
+type IRPCHost<I extends IRPCInputs, O extends IRPCOutput> = IRPCSpec<I, O> & {
+  /** The actual handler function that implements the RPC */
+  handler: IRPCHandler;
+};
+/**
+ * Factory interface for creating and managing RPC functions.
+ */
+interface IRPCFactory {
+  /**
+   * Creates a new RPC function with the given specification.
+   * @param spec The specification for the RPC function
+   */
+  <F, I extends IRPCInputs = IRPCInputs, O extends IRPCOutput = IRPCOutput>(spec: IRPCSpec<I, O>): F;
+  /** The namespace associated with this factory */
+  get namespace(): IRPCNamespace;
+  /**
+   * Sets the transport mechanism for this factory.
+   * @param transport The transport to use
+   */
+  use(transport: IRPCTransport): IRPCFactory;
+  /**
+   * Gets the specification for an RPC function by name.
+   * @param name The name of the RPC function
+   */
+  get<I extends IRPCInputs, O extends IRPCOutput>(name: string): IRPCSpec<I, O>;
+  /**
+   * Configures the module settings for this factory.
+   * @param config Partial configuration for the module
+   */
+  configure(config: Partial<IRPCModule>): IRPCFactory;
+  /**
+   * Constructs an RPC function with its handler.
+   * @param irpc The RPC function
+   * @param handler The handler that implements the RPC function
+   */
+  construct<F>(irpc: F, handler: F): IRPCFactory;
+  /**
+   * Gets information about an RPC request.
+   * @param req The RPC request
+   */
+  info<I extends IRPCInputs, O extends IRPCOutput>(req: IRPCRequest): IRPCSpec<I, O>;
+  /**
+   * Resolves an RPC request.
+   * @param req The RPC request to resolve
+   */
+  resolve<R>(req: IRPCRequest): Promise<R>;
+}
+/**
+ * Represents an incoming RPC request.
+ */
+type IRPCRequest = {
+  /** Unique identifier for the request */
+  id: string;
+  /** Name of the RPC function being called */
+  name: string;
+  /** Arguments for the RPC function */
+  args: unknown[];
+};
+/**
+ * Represents an RPC response.
+ */
+type IRPCResponse = {
+  /** Unique identifier matching the request */
+  id: string;
+  /** Name of the RPC function that was called */
+  name: string;
+  /** Error message if the call failed */
+  error?: string;
+  /** Result of the RPC call if successful */
+  result?: unknown;
+};
+/**
+ * Abstract base class for RPC transport mechanisms.
+ */
+declare abstract class IRPCTransport {
+  /**
+   * Sends RPC calls and returns the responses.
+   * @param calls Array of RPC calls to send
+   */
+  abstract send(calls: IRPCCall[]): Promise<IRPCResponse[]>;
+}
+/**
+ * Context storage mechanism for RPC operations.
+ */
+type IRPCContext<K, V> = Map<K, V>;
+/**
+ * Interface for managing RPC context stores.
+ */
+type IRPCContextProvider = {
+  /**
+   * Runs a function within a specific context.
+   * @param ctx The context to run within
+   * @param fn The function to execute
+   */
+  run<R, K, V>(ctx: IRPCContext<K, V>, fn: () => R): R;
+  /** Gets the current context store */
+  getStore<K, V>(): IRPCContext<K, V>;
+};
+//#endregion
+export { IRPCArraySchema, IRPCAuthorizer, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCFactory, IRPCHandler, IRPCHost, IRPCInputs, IRPCModule, IRPCNamespace, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRegistry, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCStore, IRPCTransport };

package/dist/types.js

@@ -0,0 +1,8 @@
+//#region src/types.ts
+/**
+* Abstract base class for RPC transport mechanisms.
+*/
+var IRPCTransport = class {};
+
+//#endregion
+export { IRPCTransport };

package/dist/utils.d.ts

@@ -0,0 +1,17 @@
+//#region src/utils.d.ts
+/**
+ * Generates a short unique identifier string.
+ *
+ * This function creates a unique ID by combining:
+ * - A timestamp in base-36 format
+ * - A sequence number in base-36 format (padded to 3 characters)
+ * - A random string in base-36 format (4 characters)
+ *
+ * The sequence number ensures uniqueness when multiple IDs are generated within the same millisecond.
+ * The random part adds additional entropy to reduce predictability.
+ *
+ * @returns A unique string identifier
+ */
+declare function shortId(): string;
+//#endregion
+export { shortId };

package/dist/utils.js

@@ -0,0 +1,26 @@
+//#region src/utils.ts
+let lastTimestamp = 0;
+let sequence = 0;
+/**
+* Generates a short unique identifier string.
+* 
+* This function creates a unique ID by combining:
+* - A timestamp in base-36 format
+* - A sequence number in base-36 format (padded to 3 characters)
+* - A random string in base-36 format (4 characters)
+* 
+* The sequence number ensures uniqueness when multiple IDs are generated within the same millisecond.
+* The random part adds additional entropy to reduce predictability.
+* 
+* @returns A unique string identifier
+*/
+function shortId() {
+	const timestamp = Date.now();
+	if (timestamp === lastTimestamp) sequence++;
+	else sequence = 0;
+	lastTimestamp = timestamp;
+	return `${timestamp.toString(36)}${sequence.toString(36).padStart(3, "0")}${Math.random().toString(36).substring(2, 6)}`;
+}
+
+//#endregion
+export { shortId };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "type": "module",
+  "name": "@irpclib/irpc",
+  "version": "0.0.1",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "directories": {
+    "dist": "./dist"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.3",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
+    "esbuild-raw-plugin": "^0.3.1",
+    "prettier": "^3.6.2",
+    "publint": "^0.3.15",
+    "rimraf": "^6.0.1",
+    "tsdown": "^0.15.9",
+    "vite": "^7.1.12",
+    "vitest": "^3.2.4",
+    "zod": "^4.1.5",
+    "@types/bun": "1.3.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5.9.0"
+  },
+  "optionalDependencies": {
+    "zod": "^4.1.5"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "clean": "rimraf dist",
+    "build": "tsdown && publint",
+    "format": "prettier --write .",
+    "test": "rimraf coverage && vitest --run",
+    "test:preview": "rimraf coverage && vitest --run && vite preview --outDir coverage",
+    "prepublish": "bun run format && bun run clean && tsdown && publint"
+  },
+  "license": "MIT"
+}

package/readme.md

@@ -0,0 +1,166 @@
+# IRPC - Isomorphic Remote Procedure Call
+
+IRPC (Isomorphic Remote Procedure Call) is a revolutionary approach to distributed computing that eliminates the cognitive overhead of network communication. It enables developers to invoke remote functions with the same ergonomics as local function calls, abstracting away the transport layer entirely.
+
+Unlike traditional approaches like REST APIs, GraphQL, or gRPC, IRPC removes the need to think about endpoints, serialization, or transport protocols. You focus on business logic while IRPC handles the communication complexity transparently.
+
+## Learn More
+
+For detailed documentation, visit [https://irpc.anchorlib.dev](https://irpc.anchorlib.dev)
+
+## Quick Start
+
+### Create a Module
+
+```ts
+import { createModule } from '@irpclib/irpc';
+
+const irpc = createModule({ name: 'my-module', version: '1.0.0' });
+```
+
+### Define Functions
+
+```ts
+export const greet = irpc<(name: string) => Promise<string>>({
+  name: 'greet'
+});
+```
+
+### Set up Transport (Client-side)
+
+```ts
+import { HTTPTransport } from '@irpclib/http';
+
+export const transport = new HTTPTransport(
+  {
+    baseURL: 'http://localhost:3000',
+    endpoint: '/rpc',
+  },
+  irpc
+);
+```
+
+### Implement Handlers (Server-side)
+
+```ts
+irpc.construct(greet, async (name) => {
+  return `Hello, ${name}!`;
+});
+```
+
+### Server Setup
+
+```ts
+import { setContextStore } from '@irpclib/irpc';
+import { AsyncLocalStorage } from 'async_hooks';
+
+setContextStore(new AsyncLocalStorage());
+
+Bun.serve({
+  routes: {
+    [transport.endpoint]: {
+      GET: () => new Response('OK'),
+      POST: (req) => transport.respond(req),
+    }
+  },
+});
+```
+
+### Client Usage
+
+```ts
+import { greet } from './my-module';
+
+const message = await greet('World');
+console.log(message); // "Hello, World!"
+```
+
+## Key Features
+
+- **Isomorphic Design**: Call functions identically on client and server
+- **Zero Boilerplate**: No REST endpoints, no GraphQL schemas, no complex serialization
+- **Transport Agnostic**: Switch between HTTP, WebSockets, and other transports without changing your business logic
+- **End-to-End Type Safety**: Compile-time validation from client to server
+- **Performance Optimized**: Intelligent batching and connection reuse
+
+## Core Components
+
+### Module
+
+A module is a container for your IRPC functions. It manages the registry of functions and their implementations.
+
+```ts
+const irpc = createModule({ name: 'fs', version: '1.0.0' });
+```
+
+### Function
+
+Functions are the core building blocks of IRPC. They define the interface for remote calls and can be implemented on the server side.
+
+```ts
+export const readFile = irpc<(path: string) => Promise<string>>('readFile');
+```
+
+### Transport
+
+Transports handle the actual communication between client and server. IRPC is transport-agnostic, allowing you to switch between different communication protocols.
+
+```ts
+export const transport = new IRPCHttpTransport(
+  {
+    baseURL: 'http://localhost:3000',
+    endpoint: '/rpc',
+    timeout: 1000,
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  },
+  irpc
+);
+```
+
+The transport automatically registers itself with the IRPC module during construction, so there's no need to manually register it.
+
+## Usage
+
+### Client
+
+On the client side, you simply import and call your functions as if they were local:
+
+```ts
+import { readFile } from './fs';
+
+console.log(await readFile('/path/to/file'));
+```
+
+### Server
+
+On the server side, you implement the actual functionality for your functions:
+
+```ts
+import { transport } from './fs';
+import { setContextStore } from '@irpclib/irpc';
+
+setContextStore(new AsyncLocalStorage());
+
+Bun.serve({
+  routes: {
+    [transport.endpoint]: {
+      GET: () => {
+        return new Response('Ok!');
+      },
+      POST: (req) => transport.respond(req),
+    }
+  },
+});
+```
+
+#### Handler
+
+Handlers are the actual implementations of your remote functions:
+
+```ts
+irpc.construct(readFile, async (path) => {
+  // Implementation goes here
+});
+```