@titanpl/native 7.0.0-beta → 7.0.1

package/index.d.ts

@@ -31,8 +31,28 @@ export interface ShareContext {
 }
 
 // Add more as needed based on native/index.js
+export interface WebSocketModule {
+    send(socketId: string, message: string): void;
+    broadcast(message: string): void;
+}
+
 export const db: any;
-export const ws: any;
+/**
+ * WebSocket communication utilities.
+ *
+ * @example
+ * ```js
+ * import { ws } from "@titanpl/native";
+ * 
+ * export default function chat(req) {
+ *   if (req.event === "open") {
+ *     ws.send(req.socketId, "Welcome!");
+ *     ws.broadcast("Someone joined.");
+ *   }
+ * }
+ * ```
+ */
+export const ws: WebSocketModule;
 export const path: any;
 export const jwt: any;
 export const password: any;
@@ -47,5 +67,27 @@ export const net: any;
 export const proc: any;
 export const time: any;
 export const url: any;
+/**
+ * HTTP Response builder utilities.
+ *
+ * @example
+ * ```js
+ * import { response } from "@titanpl/native";
+ * 
+ * export function get(req) {
+ *   return response.json({ hello: "world" });
+ * }
+ * ```
+ */
 export const response: any;
 export const valid: any;
+
+// Serialization
+/** Binary-serializes a JavaScript value using V8's fast internal format. */
+export function serialize(value: any): Uint8Array;
+/** Binary-serializes a JavaScript value using V8's fast internal format. Alias for serialize. */
+export function serialise(value: any): Uint8Array;
+/** Deserializes a Uint8Array back into its original JavaScript value/object. */
+export function deserialize(buffer: Uint8Array): any;
+/** Deserializes a Uint8Array back into its original JavaScript value/object. Alias for deserialize. */
+export function deserialise(buffer: Uint8Array): any;

package/index.js

@@ -39,5 +39,12 @@ export const time = t.time;
 export const url = t.url;
 export const response = t.response;
 export const valid = t.valid;
+export const drift = globalThis.drift;
+
+// Serialization
+export const serialize = t.serialize;
+export const serialise = t.serialise;
+export const deserialize = t.deserialize;
+export const deserialise = t.deserialise;
 
 export const defineAction = (handler) => handler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/native",
-  "version": "7.0.0-beta",
+  "version": "7.0.1",
   "description": "Titan native utilities package",
   "type": "module",
   "keywords": [
@@ -20,7 +20,7 @@
     }
   },
   "dependencies": {
-    "@titanpl/core": "latest",
+    "@titanpl/core": "7.0.0",
     "@titanpl/node": "latest"
   }
 }

package/t.native.d.ts

@@ -233,6 +233,46 @@ export const password: typeof t.password;
  */
 export const db: typeof t.db;
 
+/**
+ * WebSocket communication utilities.
+ *
+ * @example
+ * ```js
+ * import { ws } from "@titanpl/native";
+ * 
+ * export default function chat(req) {
+ *   if (req.event === "open") {
+ *     ws.send(req.socketId, "Welcome!");
+ *     ws.broadcast("Someone joined.");
+ *   }
+ * }
+ * ```
+ *
+ * Re-exported from the `t` global for module-style imports.
+ * @see {@link TitanRuntimeUtils.ws} for full documentation.
+ */
+export const ws: typeof t.ws;
+
+/**
+ * Binary serialization using V8's fast format.
+ *
+ * Re-exported from the `t` global for module-style imports.
+ * @see {@link TitanRuntimeUtils.serialize}
+ */
+export const serialize: typeof t.serialize;
+/** Alias for serialize. @see {@link TitanRuntimeUtils.serialise} */
+export const serialise: typeof t.serialise;
+
+/**
+ * Binary deserialization for V8 buffers.
+ *
+ * Re-exported from the `t` global for module-style imports.
+ * @see {@link TitanRuntimeUtils.deserialize}
+ */
+export const deserialize: typeof t.deserialize;
+/** Alias for deserialize. @see {@link TitanRuntimeUtils.deserialise} */
+export const deserialise: typeof t.deserialise;
+
 /**
  * Async file system operations (read, write, mkdir, stat, etc.).
  *
@@ -345,6 +385,23 @@ export const time: typeof t.time;
  */
 export const url: typeof t.url;
 
+/**
+ * HTTP Response builder utilities.
+ *
+ * @example
+ * ```js
+ * import { response } from "@titanpl/native";
+ * 
+ * export function get(req) {
+ *   return response.json({ hello: "world" });
+ * }
+ * ```
+ *
+ * Re-exported from the `t` global for module-style imports.
+ * @see {@link TitanRuntimeUtils.response} for full documentation.
+ */
+export const response: typeof t.response;
+
 /**
  * Runtime validation utilities.
  *
@@ -647,6 +704,55 @@ declare global {
             body?: string;
             error?: string;
         }>;
+        
+        /**
+         * Fast binary serialization using V8's internal value format.
+         *
+         * Highly efficient for complex JavaScript objects including `Date`, `Map`, 
+         * `Set`, and `TypedArrays`. The resulting `Uint8Array` is stable and
+         * can be safely stored in databases (e.g. `t.ls`) or transmitted.
+         *
+         * @param value - The JavaScript value/object to serialize.
+         * @returns A `Uint8Array` containing the binary-serialized representation.
+         *
+         * @example
+         * ```js
+         * const complex = { date: new Date(), map: new Map([["a", 1]]) };
+         * const bytes = t.serialize(complex);
+         * // Store bytes in database or pass to another action
+         * ```
+         */
+        serialize(value: any): Uint8Array;
+
+        /** 
+         * Binary serialization. Alias for `t.serialize`. 
+         * @see {@link TitanRuntimeUtils.serialize}
+         */
+        serialise(value: any): Uint8Array;
+
+        /**
+         * Deserializes a binary buffer back into its original JavaScript value.
+         *
+         * Restores full object fidelity including native types like `Date` and `Buffer`.
+         * Performance is significantly faster than `JSON.parse` for large objects.
+         *
+         * @param buffer - A `Uint8Array` created by `t.serialize()`.
+         * @returns The restored JavaScript value or object.
+         * @throws If the buffer is invalid or contains corrupted V8 header data.
+         *
+         * @example
+         * ```js
+         * const restored = t.deserialize(bytes);
+         * console.log(restored.date instanceof Date); // true
+         * ```
+         */
+        deserialize(buffer: Uint8Array): any;
+
+        /** 
+         * Binary deserialization. Alias for `t.deserialize`. 
+         * @see {@link TitanRuntimeUtils.deserialize}
+         */
+        deserialise(buffer: Uint8Array): any;
 
         /**
          * WebSocket communication utilities.
@@ -655,10 +761,12 @@ declare global {
          *
          * @example
          * ```js
+         * import { ws } from "@titanpl/native";
+         * 
          * export default function chat(req) {
          *   if (req.event === "open") {
-         *     t.ws.send(req.socketId, "Welcome!");
-         *     t.ws.broadcast("Someone joined.");
+         *     ws.send(req.socketId, "Welcome!");
+         *     ws.broadcast("Someone joined.");
          *   }
          * }
          * ```
@@ -1101,6 +1209,26 @@ declare global {
         url: TitanCore.URLModule;
 
         /**
+         * HTTP Response builder utilities.
+         *
+         * Provides helpers for crafting standardized HTTP responses, such as JSON,
+         * HTML, redirects, or raw text.
+         *
+         * @example
+         * ```js
+         * import { response } from "@titanpl/native";
+         * 
+         * export function get(req) {
+         *   if (!req.headers.authorization) {
+         *     return response.json({ error: "Unauthorized" }, 401);
+         *   }
+         *   return response.html("<h1>Welcome</h1>");
+         * }
+         * ```
+         *
+         * @see https://titanpl.vercel.app/docs/how-to-use/05-runtime-apis — Runtime APIs (t.response)
+         */
+        response: TitanCore.ResponseModule;
 
         /**
          * Runtime validation utilities.
@@ -1172,6 +1300,51 @@ declare global {
         interface TitanResponse {
             readonly __titan_response: true;
         }
+
+        /**
+         * Response builder interfaces.
+         */
+        interface ResponseModule {
+            /**
+             * Return a JSON response with an optional status code and headers.
+             * 
+             * @param data - The object or value to serialize to JSON.
+             * @param status - The HTTP status code (default: 200).
+             * @param headers - Optional custom headers.
+             * @returns A standard Titan response.
+             */
+            json(data: any, status?: number, headers?: Record<string, string>): TitanResponse;
+
+            /**
+             * Return an HTML response with an optional status code and headers.
+             * 
+             * @param html - The HTML string to return.
+             * @param status - The HTTP status code (default: 200).
+             * @param headers - Optional custom headers.
+             * @returns A standard Titan response.
+             */
+            html(html: string, status?: number, headers?: Record<string, string>): TitanResponse;
+            
+            /**
+             * Return a plain text response with an optional status code and headers.
+             * 
+             * @param text - The string to return.
+             * @param status - The HTTP status code (default: 200).
+             * @param headers - Optional custom headers.
+             * @returns A standard Titan response.
+             */
+            text(text: string, status?: number, headers?: Record<string, string>): TitanResponse;
+            
+            /**
+             * Issue an HTTP redirect to a specific URL.
+             * 
+             * @param url - The destination URL.
+             * @param status - The redirect status code (default: 302).
+             * @param headers - Optional custom headers.
+             * @returns A standard Titan response.
+             */
+            redirect(url: string, status?: number, headers?: Record<string, string>): TitanResponse;
+        }
         /**
          * Asynchronous file system operations.
          *
@@ -2123,7 +2296,7 @@ declare global {
  * - t.os
  * - t.time
  */
-    const process: {
+    var process: {
         /** Process ID */
         pid: number;