@hoox-sh/hoox-shared 1.2.0

package/dist/operator-transport.js

@@ -0,0 +1,87 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/operator-transport.ts
+function stripTrailingSlashes(url) {
+  return url.replace(/\/+$/, "");
+}
+function parseTransport(raw) {
+  if (!raw)
+    return null;
+  const v = raw.trim().toLowerCase();
+  if (VALID_TRANSPORTS.has(v)) {
+    return v;
+  }
+  return null;
+}
+function resolveOperatorTransportProfile(env = process.env, options = {}) {
+  const accessClientId = env.CF_ACCESS_CLIENT_ID?.trim() ?? "";
+  const accessClientSecret = env.CF_ACCESS_CLIENT_SECRET?.trim() ?? "";
+  const hasAccess = Boolean(accessClientId && accessClientSecret);
+  const explicit = parseTransport(env.HOOX_TRANSPORT) ?? parseTransport(options.configTransport);
+  const transport = explicit ?? (hasAccess ? "access" : "public");
+  const apiFromEnv = env.HOOX_API_URL?.trim();
+  const apiFromConfig = options.configApiUrl?.trim();
+  const tokenFromEnv = env.HOOX_API_TOKEN?.trim();
+  const tokenFromConfig = options.configApiToken?.trim();
+  return {
+    transport,
+    apiBase: stripTrailingSlashes(apiFromEnv || apiFromConfig || DEFAULT_API_BASE),
+    bearerToken: tokenFromEnv || tokenFromConfig || "",
+    accessClientId,
+    accessClientSecret
+  };
+}
+function buildOperatorAuthHeaders(profile) {
+  const headers = {};
+  if (profile.bearerToken) {
+    headers.Authorization = `Bearer ${profile.bearerToken}`;
+  }
+  const useAccessHeaders = profile.transport === "access" || Boolean(profile.accessClientId) && Boolean(profile.accessClientSecret);
+  if (useAccessHeaders && profile.accessClientId && profile.accessClientSecret) {
+    headers["CF-Access-Client-Id"] = profile.accessClientId;
+    headers["CF-Access-Client-Secret"] = profile.accessClientSecret;
+  }
+  return headers;
+}
+function hasOperatorClientCredentials(profile) {
+  if (profile.bearerToken)
+    return true;
+  return Boolean(profile.accessClientId && profile.accessClientSecret);
+}
+function operatorUrl(profile, path) {
+  const base = profile.apiBase.replace(/\/+$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${p}`;
+}
+var DEFAULT_API_BASE = "http://localhost:8787", VALID_TRANSPORTS;
+var init_operator_transport = __esm(() => {
+  VALID_TRANSPORTS = new Set([
+    "public",
+    "access",
+    "mtls",
+    "tunnel"
+  ]);
+});
+init_operator_transport();
+
+export {
+  resolveOperatorTransportProfile,
+  operatorUrl,
+  hasOperatorClientCredentials,
+  buildOperatorAuthHeaders
+};

package/dist/path-utils.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Branded type for Hoox paths to prevent accidental string usage.
+ * This ensures type safety when working with paths.
+ */
+export type HooxPath = string & {
+    readonly __brand: "HooxPath";
+};
+/** Where resolveHooxRuntimeRoot found (or failed to find) a setup monorepo. */
+export type RuntimeRootSource = "env" | "cwd" | "global" | "none";
+/** Result of resolveHooxRuntimeRoot(). */
+export interface RuntimeRootResult {
+    /** Absolute monorepo root, or null if none found. */
+    root: string | null;
+    /** Which resolution step produced the result. */
+    source: RuntimeRootSource;
+    /** Paths inspected (for doctor / error messages). */
+    checked: {
+        env?: string;
+        cwd: string | null;
+        global: string;
+    };
+}
+/**
+ * Gets the Hoox home directory location: $HOME/.hoox
+ *
+ * Behavior:
+ * - HOOX_HOME env wins when set (absolute or relative, then resolved)
+ * - Else $HOME/.hoox on macOS, Linux, Windows
+ * - Falls back to current working directory if HOME is not available
+ * - Resolves to absolute path
+ *
+ * @returns Absolute path to $HOME/.hoox as a branded HooxPath
+ * @throws Never — always returns a valid path
+ *
+ * @example
+ * ```typescript
+ * const hooxHome = getHooxHome();
+ * // Returns: "/Users/alice/.hoox" (macOS)
+ * // Returns: "/home/alice/.hoox" (Linux)
+ * // Returns: "C:\\Users\\alice\\.hoox" (Windows)
+ * ```
+ */
+export declare function getHooxHome(): HooxPath;
+/**
+ * True when `dir` looks like a hoox monorepo root.
+ *
+ * Markers match CLI verifyRepoRoot: root wrangler.jsonc + packages/cli package.
+ */
+export declare function isHooxSetupRoot(dir: string): boolean;
+/**
+ * Walk up from `startDir` looking for a hoox monorepo root.
+ *
+ * @returns Absolute root path, or null if not found
+ */
+export declare function findHooxSetupRoot(startDir?: string): string | null;
+/**
+ * Resolve the Hoox tool/runtime monorepo root (local checkout or global clone).
+ *
+ * Order:
+ *   1. HOOX_REPO — must pass isHooxSetupRoot or result is source "env" with root null
+ *   2. Walk up from cwd
+ *   3. getHooxRepoPath() ($HOME/.hoox/repo or $HOOX_HOME/repo)
+ *
+ * Project cwd and tool root are intentionally separate: a random project
+ * directory can still use the global runtime for TUI / templates.
+ */
+export declare function resolveHooxRuntimeRoot(options?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): RuntimeRootResult;
+/**
+ * Candidate TUI entry files under a monorepo root (source first, then dist).
+ */
+export declare function getTuiEntryCandidates(runtimeRoot: string): string[];
+/**
+ * Resolves a relative path within the Hoox home directory.
+ *
+ * Behavior:
+ * - Joins the relative path with $HOME/.hoox
+ * - Resolves to absolute path
+ * - Prevents path traversal attacks (../ sequences)
+ *
+ * @param relativePath - Path relative to $HOME/.hoox (e.g., "repo", "config/wrangler.jsonc")
+ * @returns Absolute path as a branded HooxPath
+ * @throws Error if path contains suspicious traversal patterns
+ *
+ * @example
+ * ```typescript
+ * const repoPath = resolveHooxPath("repo");
+ * // Returns: "/Users/alice/.hoox/repo"
+ *
+ * const configPath = resolveHooxPath("config/wrangler.jsonc");
+ * // Returns: "/Users/alice/.hoox/config/wrangler.jsonc"
+ * ```
+ */
+export declare function resolveHooxPath(relativePath: string): HooxPath;
+/**
+ * Checks if a given path is within the Hoox home directory.
+ *
+ * @param path - Path to check
+ * @returns true if path is within $HOME/.hoox, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isWithinHooxHome("/Users/alice/.hoox/repo"); // true
+ * isWithinHooxHome("/Users/alice/other"); // false
+ * ```
+ */
+export declare function isWithinHooxHome(path: string): boolean;
+/**
+ * Gets the relative path from Hoox home directory.
+ *
+ * @param absolutePath - Absolute path to resolve
+ * @returns Relative path from $HOME/.hoox, or null if path is outside Hoox home
+ *
+ * @example
+ * ```typescript
+ * getRelativeHooxPath("/Users/alice/.hoox/repo/src");
+ * // Returns: "repo/src"
+ *
+ * getRelativeHooxPath("/Users/alice/other");
+ * // Returns: null
+ * ```
+ */
+export declare function getRelativeHooxPath(absolutePath: string): string | null;
+/**
+ * Constructs a path to the Hoox repository location.
+ *
+ * @returns Path to $HOME/.hoox/repo as a branded HooxPath
+ *
+ * @example
+ * ```typescript
+ * const repoPath = getHooxRepoPath();
+ * // Returns: "/Users/alice/.hoox/repo"
+ * ```
+ */
+export declare function getHooxRepoPath(): HooxPath;
+/**
+ * Constructs a path to the Hoox configuration directory.
+ *
+ * @returns Path to $HOME/.hoox/config as a branded HooxPath
+ *
+ * @example
+ * ```typescript
+ * const configDir = getHooxConfigDir();
+ * // Returns: "/Users/alice/.hoox/config"
+ * ```
+ */
+export declare function getHooxConfigDir(): HooxPath;
+/**
+ * Constructs a path to the Hoox data directory.
+ *
+ * @returns Path to $HOME/.hoox/data as a branded HooxPath
+ *
+ * @example
+ * ```typescript
+ * const dataDir = getHooxDataDir();
+ * // Returns: "/Users/alice/.hoox/data"
+ * ```
+ */
+export declare function getHooxDataDir(): HooxPath;
+/**
+ * Constructs a path to the Hoox wrangler configuration file.
+ *
+ * @returns Path to $HOME/.hoox/config/wrangler.jsonc as a branded HooxPath
+ *
+ * @example
+ * ```typescript
+ * const wranglerPath = getHooxWranglerPath();
+ * // Returns: "/Users/alice/.hoox/config/wrangler.jsonc"
+ * ```
+ */
+export declare function getHooxWranglerPath(): HooxPath;
+/**
+ * Constructs a path to the Hoox state file.
+ *
+ * @returns Path to $HOME/.hoox/data/state.json as a branded HooxPath
+ *
+ * @example
+ * ```typescript
+ * const statePath = getHooxStatePath();
+ * // Returns: "/Users/alice/.hoox/data/state.json"
+ * ```
+ */
+export declare function getHooxStatePath(): HooxPath;
+//# sourceMappingURL=path-utils.d.ts.map

package/dist/path-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.d.ts","sourceRoot":"","sources":["../src/path-utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA0BH;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;CAAE,CAAC;AAEjE,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;AAElE,0CAA0C;AAC1C,MAAM,WAAW,iBAAiB;IAChC,qDAAqD;IACrD,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,iDAAiD;IACjD,MAAM,EAAE,iBAAiB,CAAC;IAC1B,qDAAqD;IACrD,OAAO,EAAE;QACP,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAUD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,IAAI,QAAQ,CAgBtC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAWpD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,GAAE,MAAsB,GAC/B,MAAM,GAAG,IAAI,CAQf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE;IAC/C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB,GAAG,iBAAiB,CAoDpB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAOnE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,QAAQ,CAiC9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAStD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAkBvE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,IAAI,QAAQ,CAE1C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,IAAI,QAAQ,CAE3C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,IAAI,QAAQ,CAEzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,IAAI,QAAQ,CAE9C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,IAAI,QAAQ,CAE3C"}

package/dist/path-utils.js

@@ -0,0 +1,188 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/path-utils.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+function createHooxPath(path) {
+  return path;
+}
+function getHooxHome() {
+  try {
+    const override = process.env.HOOX_HOME?.trim();
+    if (override) {
+      return createHooxPath(resolve(override));
+    }
+    const home = homedir();
+    if (!home || home.length === 0) {
+      return createHooxPath(resolve(process.cwd(), ".hoox"));
+    }
+    return createHooxPath(join(home, ".hoox"));
+  } catch {
+    return createHooxPath(resolve(process.cwd(), ".hoox"));
+  }
+}
+function isHooxSetupRoot(dir) {
+  if (!dir)
+    return false;
+  try {
+    const root = resolve(dir);
+    return existsSync(join(root, "wrangler.jsonc")) && existsSync(join(root, "packages", "cli", "package.json"));
+  } catch {
+    return false;
+  }
+}
+function findHooxSetupRoot(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  for (;; ) {
+    if (isHooxSetupRoot(dir))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function resolveHooxRuntimeRoot(options) {
+  const env = options?.env ?? process.env;
+  const cwd = resolve(options?.cwd ?? process.cwd());
+  const globalRepo = getHooxRepoPath();
+  const envRepo = env.HOOX_REPO?.trim();
+  if (envRepo) {
+    const resolved = resolve(envRepo);
+    if (isHooxSetupRoot(resolved)) {
+      return {
+        root: resolved,
+        source: "env",
+        checked: {
+          env: resolved,
+          cwd: findHooxSetupRoot(cwd),
+          global: globalRepo
+        }
+      };
+    }
+    return {
+      root: null,
+      source: "env",
+      checked: {
+        env: resolved,
+        cwd: findHooxSetupRoot(cwd),
+        global: globalRepo
+      }
+    };
+  }
+  const local = findHooxSetupRoot(cwd);
+  if (local) {
+    return {
+      root: local,
+      source: "cwd",
+      checked: { cwd: local, global: globalRepo }
+    };
+  }
+  if (isHooxSetupRoot(globalRepo)) {
+    return {
+      root: globalRepo,
+      source: "global",
+      checked: { cwd: null, global: globalRepo }
+    };
+  }
+  return {
+    root: null,
+    source: "none",
+    checked: { cwd: null, global: globalRepo }
+  };
+}
+function getTuiEntryCandidates(runtimeRoot) {
+  const root = resolve(runtimeRoot);
+  return [
+    join(root, "packages", "tui", "src", "main.tsx"),
+    join(root, "packages", "tui", "dist", "main.js"),
+    join(root, "packages", "tui", "src", "main.ts")
+  ];
+}
+function resolveHooxPath(relativePath) {
+  if (!relativePath || typeof relativePath !== "string") {
+    throw new Error("relativePath must be a non-empty string");
+  }
+  if (relativePath.includes("..")) {
+    throw new Error(`Path traversal detected in relativePath: "${relativePath}"`);
+  }
+  const normalizedPath = relativePath.replace(/\\/g, "/");
+  const hooxHome = getHooxHome();
+  const fullPath = join(hooxHome, normalizedPath);
+  const resolvedPath = resolve(fullPath);
+  const resolvedHome = resolve(hooxHome);
+  if (!resolvedPath.startsWith(resolvedHome)) {
+    throw new Error(`Resolved path "${resolvedPath}" is outside Hoox home directory`);
+  }
+  return createHooxPath(resolvedPath);
+}
+function isWithinHooxHome(path) {
+  try {
+    const hooxHome = getHooxHome();
+    const resolvedPath = resolve(path);
+    const resolvedHome = resolve(hooxHome);
+    return resolvedPath.startsWith(resolvedHome);
+  } catch {
+    return false;
+  }
+}
+function getRelativeHooxPath(absolutePath) {
+  try {
+    if (!isWithinHooxHome(absolutePath)) {
+      return null;
+    }
+    const hooxHome = getHooxHome();
+    const resolvedPath = resolve(absolutePath);
+    const resolvedHome = resolve(hooxHome);
+    const relativePath = resolvedPath.slice(resolvedHome.length);
+    return relativePath.startsWith("/") || relativePath.startsWith("\\") ? relativePath.slice(1) : relativePath;
+  } catch {
+    return null;
+  }
+}
+function getHooxRepoPath() {
+  return resolveHooxPath("repo");
+}
+function getHooxConfigDir() {
+  return resolveHooxPath("config");
+}
+function getHooxDataDir() {
+  return resolveHooxPath("data");
+}
+function getHooxWranglerPath() {
+  return resolveHooxPath("config/wrangler.jsonc");
+}
+function getHooxStatePath() {
+  return resolveHooxPath("data/state.json");
+}
+export {
+  resolveHooxRuntimeRoot,
+  resolveHooxPath,
+  isWithinHooxHome,
+  isHooxSetupRoot,
+  getTuiEntryCandidates,
+  getRelativeHooxPath,
+  getHooxWranglerPath,
+  getHooxStatePath,
+  getHooxRepoPath,
+  getHooxHome,
+  getHooxDataDir,
+  getHooxConfigDir,
+  findHooxSetupRoot
+};

package/dist/queue-handler.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { MessageBatch } from "@cloudflare/workers-types";
+export interface QueueHandlerOptions<T> {
+    /** Maximum number of retry attempts */
+    maxRetries: number;
+    /** Array of delay times in seconds for exponential backoff */
+    backoffDelays: number[];
+    /** Handler function called for each message */
+    onMessage: (message: T, attemptNumber: number) => Promise<unknown> | unknown;
+    /** Called when a message fails and will be retried */
+    onRetry?: (message: T, attemptNumber: number, error: string, delaySeconds: number) => void | Promise<void>;
+    /** Called when message is moved to DLQ (max retries exceeded) */
+    onDLQ?: (message: T, attemptNumber: number, error: string) => void | Promise<void>;
+    /** Logger function for debugging */
+    logger?: {
+        info(msg: string, data?: unknown): void;
+        error(msg: string, data?: unknown): void;
+    };
+}
+/**
+ * Creates a reusable queue handler with retry + exponential backoff logic.
+ *
+ * Usage:
+ * ```typescript
+ * const handler = createQueueHandler({
+ *   maxRetries: 5,
+ *   backoffDelays: [0, 30, 60, 300, 900],
+ *   onMessage: async (msg) => {
+ *     await executeTask(msg);
+ *   },
+ *   onDLQ: async (msg, attempts, error) => {
+ *     await logFailedTask(msg, error);
+ *   }
+ * });
+ *
+ * export default {
+ *   async queue(batch, env, ctx) {
+ *     return await handler(batch);
+ *   }
+ * };
+ * ```
+ */
+export declare function createQueueHandler<T>(options: QueueHandlerOptions<T>): (batch: MessageBatch<T>) => Promise<void>;
+//# sourceMappingURL=queue-handler.d.ts.map

package/dist/queue-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-handler.d.ts","sourceRoot":"","sources":["../src/queue-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,8DAA8D;IAC9D,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,+CAA+C;IAC/C,SAAS,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAC7E,sDAAsD;IACtD,OAAO,CAAC,EAAE,CACR,OAAO,EAAE,CAAC,EACV,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,KACjB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,iEAAiE;IACjE,KAAK,CAAC,EAAE,CACN,OAAO,EAAE,CAAC,EACV,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,KACV,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,oCAAoC;IACpC,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;QACxC,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;KAC1C,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,IAIrD,OAAO,YAAY,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,IAAI,CAAC,CAmCrD"}

package/dist/queue-handler.js

@@ -0,0 +1,46 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/queue-handler.ts
+function createQueueHandler(options) {
+  const { maxRetries, backoffDelays, onMessage, onRetry, onDLQ, logger } = options;
+  return async (batch) => {
+    for (const msg of batch.messages) {
+      const attemptNumber = msg.attempts || 0;
+      const logId = `[${msg.id}]`;
+      try {
+        logger?.info(`${logId} Processing message (attempt ${attemptNumber + 1})`);
+        await onMessage(msg.body, attemptNumber);
+        logger?.info(`${logId} Message processed successfully`);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        if (attemptNumber < maxRetries) {
+          const delaySeconds = backoffDelays[attemptNumber] ?? backoffDelays[backoffDelays.length - 1];
+          logger?.info(`${logId} Retrying in ${delaySeconds}s (attempt ${attemptNumber + 2}/${maxRetries + 1})`);
+          await onRetry?.(msg.body, attemptNumber, errorMsg, delaySeconds);
+          msg.retry({ delaySeconds });
+        } else {
+          logger?.error(`${logId} Max retries exceeded (${maxRetries + 1} attempts), moving to DLQ`);
+          await onDLQ?.(msg.body, attemptNumber, errorMsg);
+        }
+      }
+    }
+  };
+}
+export {
+  createQueueHandler
+};

package/dist/router.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Router implementation for Cloudflare Workers
+ * Provides standardized routing across all workers with path parameter support
+ *
+ * Supports exact matching (fast path) and pattern matching for `:param` segments.
+ * Path parameters are extracted and passed as the 4th argument to handlers.
+ */
+import type { Router } from "./types/router";
+export type { Handler, MiddlewareHandler, RouteParams } from "./types/router";
+export declare function createRouter<TEnv = unknown>(): Router<TEnv>;
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AAEH,OAAO,KAAK,EAKV,MAAM,EACP,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EAAE,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE9E,wBAAgB,YAAY,CAAC,IAAI,GAAG,OAAO,KAAK,MAAM,CAAC,IAAI,CAAC,CAsM3D"}