@jango-blockchained/hoox-shared 1.0.8 → 1.1.0

package/dist/path-utils.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Path Resolution Service for Hoox
+ *
+ * Provides cross-OS utilities for resolving the $HOME/.hoox directory location
+ * and constructing type-safe paths within it.
+ *
+ * Supports macOS, Linux, and Windows with proper fallback handling.
+ *
+ * Runtime layout:
+ *   $HOME/.hoox/              — getHooxHome() (override with HOOX_HOME)
+ *   $HOME/.hoox/repo/         — managed clone of hoox-setup (getHooxRepoPath)
+ *   $HOME/.hoox/config/       — user config
+ *   $HOME/.hoox/data/         — persistent state
+ *
+ * Tool/runtime resolution (resolveHooxRuntimeRoot):
+ *   1. HOOX_REPO env (explicit monorepo path)
+ *   2. Walk up from cwd for a local hoox-setup checkout
+ *   3. $HOME/.hoox/repo (global managed clone)
+ */
+/**
+ * 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-setup 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-setup 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;;;;;;;;;;;;;;;;;;GAkBG;AAMH;;;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,43 @@
+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,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

@@ -6,6 +6,6 @@
  * Path parameters are extracted and passed as the 4th argument to handlers.
  */
 import type { Router } from "./types/router";
-export type { Handler, RouteParams } from "./types/router";
-export declare function createRouter<TEnv = Record<string, unknown>>(): Router<TEnv>;
+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

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAIV,MAAM,EACP,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE3D,wBAAgB,YAAY,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,CAsL3E"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA;;;;;;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"}

package/dist/router.js

@@ -52,7 +52,7 @@ function createRouter() {
     routes.push(route);
   }
   function matchRoute(path, method) {
-    const exact = routes.findLast ? routes.findLast((r) => r.path === path && r.method === method) : [...routes].reverse().find((r) => r.path === path && r.method === method);
+    const exact = routes.reduceRight((found, r) => found ?? (r.path === path && r.method === method ? r : null), null);
     if (exact)
       return { route: exact };
     for (let i = routes.length - 1;i >= 0; i--) {
@@ -85,14 +85,20 @@ function createRouter() {
       const method = request.method;
       const match = matchRoute(path, method);
       if (!match) {
-        const pathExists = routes.some((r) => {
-          if (r.path === path)
-            return true;
+        let pathExists = false;
+        for (let i = routes.length - 1;i >= 0; i--) {
+          const r = routes[i];
+          if (r.path === path) {
+            pathExists = true;
+            break;
+          }
           if (r.params && r.params.length > 0 && r.regex) {
-            return r.regex.test(path);
+            if (r.regex.test(path)) {
+              pathExists = true;
+              break;
+            }
           }
-          return false;
-        });
+        }
         if (pathExists) {
           return new Response(JSON.stringify({
             success: false,
@@ -114,7 +120,8 @@ function createRouter() {
             return result;
         }
       }
-      return match.route.handler(request, env, ctx, match.params);
+      const handlerResult = await match.route.handler(request, env, ctx, match.params);
+      return handlerResult ?? new Response(null, { status: 204 });
     }
   };
 }

package/dist/schemas/index.js

@@ -36,7 +36,7 @@ function deriveCalledBy(manifests) {
 var manifests = {
   hoox: {
     name: "hoox",
-    path: "workers/hoox",
+    path: "workers/hoox-worker",
     vars: {
       WEBHOOK_API_KEY_BINDING: {
         type: "secret",
@@ -380,6 +380,7 @@ var manifests = {
 var CALLED_BY = deriveCalledBy(manifests);
 var WORKER_MANIFESTS = manifests;
 var WORKER_NAMES = Object.keys(manifests).sort();
+
 // src/schemas/validators.ts
 import { parse } from "jsonc-parser";
 function validateWranglerJsonc(workerName, manifest, jsoncContent) {
@@ -405,7 +406,8 @@ function validateWranglerJsonc(workerName, manifest, jsoncContent) {
     });
     return errors;
   }
-  const declaredVars = parsed?.vars ?? {};
+  const wrangler = parsed;
+  const declaredVars = wrangler.vars ?? {};
   for (const [name, def] of Object.entries(manifest.vars)) {
     if (!(name in declaredVars)) {
       errors.push({
@@ -426,7 +428,7 @@ function validateWranglerJsonc(workerName, manifest, jsoncContent) {
       });
     }
   }
-  const declaredServices = parsed?.services ?? [];
+  const declaredServices = wrangler.services ?? [];
   for (const expected of manifest.services) {
     const match = declaredServices.find((s) => s.binding === expected.binding && s.service === expected.service);
     if (!match) {
@@ -482,7 +484,8 @@ function validateRootSecrets(workerName, manifest, rootJsoncContent) {
     });
     return errors;
   }
-  const rootSecrets = parsed?.workers?.[workerName]?.secrets ?? [];
+  const rootWrangler = parsed;
+  const rootSecrets = rootWrangler.workers?.[workerName]?.secrets ?? [];
   const expectedSecrets = Object.entries(manifest.vars).filter(([_, def]) => def.type === "secret").map(([name]) => name);
   for (const expected of expectedSecrets) {
     if (!rootSecrets.includes(expected)) {