tina4-nodejs 3.13.114 → 3.13.116

package/CLAUDE.md

@@ -13,13 +13,13 @@ Even if the skill text is not currently loaded, these are non-negotiable:
 
 The full discipline lives in `.claude/skills/tina4-maintainer/SKILL.md`; this block is the always-on floor.
 
-# CLAUDE.md - AI Developer Guide for tina4-nodejs (v3.13.114)
+# CLAUDE.md - AI Developer Guide for tina4-nodejs (v3.13.116)
 
 > This file helps AI assistants (Claude, Copilot, Cursor, etc.) understand and work on this codebase effectively.
 
 ## What This Project Is
 
-Tina4 for Node.js/TypeScript v3.13.114 - The Intelligent Native Application 4ramework. A convention-over-configuration structural paradigm. The developer writes TypeScript; Tina4 is invisible infrastructure.
+Tina4 for Node.js/TypeScript v3.13.116 - The Intelligent Native Application 4ramework. A convention-over-configuration structural paradigm. The developer writes TypeScript; Tina4 is invisible infrastructure.
 
 The philosophy: zero ceremony, batteries included, file system as source of truth.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.13.114",
+  "version": "3.13.116",
   "type": "module",
   "description": "Tina4 for Node.js/TypeScript - native TypeScript conventions and shared Tina4 contracts",
   "keywords": [

package/packages/cli/dist/bin.js

@@ -36727,18 +36727,24 @@ async function runGlobalMiddlewarePass(middleware, req2, res) {
   if (!res.raw.writableEnded) res.raw.end();
   return true;
 }
-async function invokeRouteHandler(match, req2, res) {
-  const routeParams = req2.params || {};
-  const fnStr = match.handler.toString();
+function resolveHandlerArgs(handler, req2, res, routeParams) {
+  const fnStr = handler.toString();
   const argMatch = fnStr.match(/^(?:async\s*)?(?:function\s*\w*)?\s*\(([^)]*)\)/);
   const argNames = argMatch?.[1]?.split(",").map((a) => a.trim().replace(/[:=].*/, "")) ?? [];
   const filteredArgs = argNames.filter((n) => n.length > 0);
-  if (filteredArgs.length === 0) return await match.handler();
-  const args = filteredArgs.map((name) => {
+  if (filteredArgs.length === 0) return [];
+  let unmatchedPos = 0;
+  return filteredArgs.map((name) => {
     if (name in routeParams) return routeParams[name];
     if (name === "request" || name === "req") return req2;
-    return res;
+    if (name === "response" || name === "res") return res;
+    return unmatchedPos++ === 0 ? req2 : res;
   });
+}
+async function invokeRouteHandler(match, req2, res) {
+  const routeParams = req2.params || {};
+  const args = resolveHandlerArgs(match.handler, req2, res, routeParams);
+  if (args.length === 0) return await match.handler();
   return await match.handler(...args);
 }
 async function renderIfTemplateRoute(match, res, result) {
@@ -38493,6 +38499,7 @@ var registry, watchedFiles, Tina4Service, ServiceRunner;
 var init_service = __esm({
   "../core/src/service.ts"() {
     "use strict";
+    init_logger();
     registry = /* @__PURE__ */ new Map();
     watchedFiles = /* @__PURE__ */ new Set();
     Tina4Service = class {
@@ -38636,6 +38643,17 @@ var init_service = __esm({
       static stop(name) {
         const targets = name ? [registry.get(name)].filter(Boolean) : Array.from(registry.values());
         for (const svc of targets) {
+          const instance = svc.instance;
+          if (instance && typeof instance.stop === "function") {
+            try {
+              instance.stop();
+            } catch (err) {
+              Log.error("Error stopping service instance", {
+                name: svc.name,
+                error: err instanceof Error ? err.message : String(err)
+              });
+            }
+          }
           svc.context.running = false;
           if (svc.timerId) {
             clearInterval(svc.timerId);

package/packages/core/dist/index.js

@@ -36706,18 +36706,24 @@ async function runGlobalMiddlewarePass(middleware, req2, res) {
   if (!res.raw.writableEnded) res.raw.end();
   return true;
 }
-async function invokeRouteHandler(match, req2, res) {
-  const routeParams = req2.params || {};
-  const fnStr = match.handler.toString();
+function resolveHandlerArgs(handler, req2, res, routeParams) {
+  const fnStr = handler.toString();
   const argMatch = fnStr.match(/^(?:async\s*)?(?:function\s*\w*)?\s*\(([^)]*)\)/);
   const argNames = argMatch?.[1]?.split(",").map((a) => a.trim().replace(/[:=].*/, "")) ?? [];
   const filteredArgs = argNames.filter((n) => n.length > 0);
-  if (filteredArgs.length === 0) return await match.handler();
-  const args = filteredArgs.map((name) => {
+  if (filteredArgs.length === 0) return [];
+  let unmatchedPos = 0;
+  return filteredArgs.map((name) => {
     if (name in routeParams) return routeParams[name];
     if (name === "request" || name === "req") return req2;
-    return res;
+    if (name === "response" || name === "res") return res;
+    return unmatchedPos++ === 0 ? req2 : res;
   });
+}
+async function invokeRouteHandler(match, req2, res) {
+  const routeParams = req2.params || {};
+  const args = resolveHandlerArgs(match.handler, req2, res, routeParams);
+  if (args.length === 0) return await match.handler();
   return await match.handler(...args);
 }
 async function renderIfTemplateRoute(match, res, result) {
@@ -38472,6 +38478,7 @@ var registry, watchedFiles, Tina4Service, ServiceRunner;
 var init_service = __esm({
   "src/service.ts"() {
     "use strict";
+    init_logger();
     registry = /* @__PURE__ */ new Map();
     watchedFiles = /* @__PURE__ */ new Set();
     Tina4Service = class {
@@ -38615,6 +38622,17 @@ var init_service = __esm({
       static stop(name) {
         const targets = name ? [registry.get(name)].filter(Boolean) : Array.from(registry.values());
         for (const svc of targets) {
+          const instance = svc.instance;
+          if (instance && typeof instance.stop === "function") {
+            try {
+              instance.stop();
+            } catch (err) {
+              Log.error("Error stopping service instance", {
+                name: svc.name,
+                error: err instanceof Error ? err.message : String(err)
+              });
+            }
+          }
           svc.context.running = false;
           if (svc.timerId) {
             clearInterval(svc.timerId);

package/packages/core/src/server.ts

@@ -999,24 +999,49 @@ async function runGlobalMiddlewarePass(
  * or nothing - and each parameter is resolved by its name: a path param wins,
  * then `request`/`req`, then the response.
  */
-async function invokeRouteHandler(
-  match: { handler: unknown },
+/**
+ * Resolve a handler's argument list to `[reqOrParam, resOrParam, ...]` values.
+ *
+ * By-name path preserved (route-param names, `req`/`request`, `res`/`response`)
+ * so existing code keeps its DX. Any remaining unmatched name falls back to
+ * POSITIONAL binding: first unmatched -> request, rest -> response. That makes
+ * dispatch bundler-safe by construction: Bun `--compile` and terser/esbuild
+ * identifier-mangling rename `(req, res)` to `(req2, r$0)` — the by-name path
+ * misses, the positional fallback catches, and the handler still receives the
+ * request as its first argument. Fixes #56.
+ *
+ * Exported so the regression test can pin the behaviour directly, without a
+ * live HTTP server.
+ */
+export function resolveHandlerArgs(
+  handler: unknown,
   req: Tina4Request,
   res: Tina4Response,
-): Promise<unknown> {
-  const routeParams = req.params || {};
-  const fnStr = (match.handler as { toString(): string }).toString();
+  routeParams: Record<string, unknown>,
+): unknown[] {
+  const fnStr = (handler as { toString(): string }).toString();
   const argMatch = fnStr.match(/^(?:async\s*)?(?:function\s*\w*)?\s*\(([^)]*)\)/);
   const argNames = argMatch?.[1]?.split(",").map((a: string) => a.trim().replace(/[:=].*/, "")) ?? [];
   const filteredArgs = argNames.filter((n: string) => n.length > 0);
+  if (filteredArgs.length === 0) return [];
 
-  if (filteredArgs.length === 0) return await (match.handler as any)();
-
-  const args = filteredArgs.map((name: string) => {
+  let unmatchedPos = 0;
+  return filteredArgs.map((name: string) => {
     if (name in routeParams) return routeParams[name];
     if (name === "request" || name === "req") return req;
-    return res;
+    if (name === "response" || name === "res") return res;
+    return (unmatchedPos++ === 0) ? req : res;
   });
+}
+
+async function invokeRouteHandler(
+  match: { handler: unknown },
+  req: Tina4Request,
+  res: Tina4Response,
+): Promise<unknown> {
+  const routeParams = req.params || {};
+  const args = resolveHandlerArgs(match.handler, req, res, routeParams);
+  if (args.length === 0) return await (match.handler as any)();
   return await (match.handler as any)(...args);
 }
 

package/packages/core/src/service.ts

@@ -5,6 +5,7 @@
 import { readdirSync, statSync, watchFile, unwatchFile } from "node:fs";
 import { join, extname } from "node:path";
 import { pathToFileURL } from "node:url";
+import { Log } from "./logger.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -40,6 +41,7 @@ interface RegisteredService {
   context: ServiceContext;
   timerId: ReturnType<typeof setInterval> | null;
   retries: number;
+  instance?: Tina4Service;
 }
 
 const registry = new Map<string, RegisteredService>();
@@ -266,11 +268,10 @@ export class ServiceRunner {
   ): void {
     const merged: ServiceOptions = { daemon: true, ...options };
     this.register(name, service.asHandler(), merged);
-    // Stash the instance on the registry entry so future stop() calls
-    // can route to service.stop().
+    // Stash the instance so stop() can route to service.stop().
     const entry = registry.get(name);
     if (entry) {
-      (entry as unknown as Record<string, unknown>).instance = service;
+      entry.instance = service;
     }
   }
 
@@ -362,6 +363,17 @@ export class ServiceRunner {
       : Array.from(registry.values());
 
     for (const svc of targets) {
+      const instance = svc.instance;
+      if (instance && typeof instance.stop === "function") {
+        try {
+          instance.stop();
+        } catch (err) {
+          Log.error("Error stopping service instance", {
+            name: svc.name,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      }
       svc.context.running = false;
       if (svc.timerId) {
         clearInterval(svc.timerId);

package/packages/orm/dist/index.js

@@ -25065,18 +25065,24 @@ async function runGlobalMiddlewarePass(middleware, req2, res) {
   if (!res.raw.writableEnded) res.raw.end();
   return true;
 }
-async function invokeRouteHandler(match, req2, res) {
-  const routeParams = req2.params || {};
-  const fnStr = match.handler.toString();
+function resolveHandlerArgs(handler, req2, res, routeParams) {
+  const fnStr = handler.toString();
   const argMatch = fnStr.match(/^(?:async\s*)?(?:function\s*\w*)?\s*\(([^)]*)\)/);
   const argNames = argMatch?.[1]?.split(",").map((a) => a.trim().replace(/[:=].*/, "")) ?? [];
   const filteredArgs = argNames.filter((n) => n.length > 0);
-  if (filteredArgs.length === 0) return await match.handler();
-  const args = filteredArgs.map((name) => {
+  if (filteredArgs.length === 0) return [];
+  let unmatchedPos = 0;
+  return filteredArgs.map((name) => {
     if (name in routeParams) return routeParams[name];
     if (name === "request" || name === "req") return req2;
-    return res;
+    if (name === "response" || name === "res") return res;
+    return unmatchedPos++ === 0 ? req2 : res;
   });
+}
+async function invokeRouteHandler(match, req2, res) {
+  const routeParams = req2.params || {};
+  const args = resolveHandlerArgs(match.handler, req2, res, routeParams);
+  if (args.length === 0) return await match.handler();
   return await match.handler(...args);
 }
 async function renderIfTemplateRoute(match, res, result) {
@@ -27299,6 +27305,7 @@ var registry, watchedFiles, Tina4Service, ServiceRunner;
 var init_service = __esm({
   "../core/src/service.ts"() {
     "use strict";
+    init_logger();
     registry = /* @__PURE__ */ new Map();
     watchedFiles = /* @__PURE__ */ new Set();
     Tina4Service = class {
@@ -27442,6 +27449,17 @@ var init_service = __esm({
       static stop(name) {
         const targets = name ? [registry.get(name)].filter(Boolean) : Array.from(registry.values());
         for (const svc of targets) {
+          const instance = svc.instance;
+          if (instance && typeof instance.stop === "function") {
+            try {
+              instance.stop();
+            } catch (err) {
+              Log.error("Error stopping service instance", {
+                name: svc.name,
+                error: err instanceof Error ? err.message : String(err)
+              });
+            }
+          }
           svc.context.running = false;
           if (svc.timerId) {
             clearInterval(svc.timerId);

package/types/core/src/server.d.ts

@@ -1,5 +1,5 @@
 import { IncomingMessage, ServerResponse } from "node:http";
-import type { Tina4Config } from "./types.js";
+import type { Tina4Config, Tina4Request, Tina4Response } from "./types.js";
 import { Router } from "./router.js";
 import { MiddlewareChain } from "./middleware.js";
 /** How long a graceful shutdown waits for in-flight requests, in seconds. */
@@ -167,6 +167,28 @@ export declare function stop(): void;
  * Useful for testing and embedding.
  */
 export declare function handle(rawReq: IncomingMessage, rawRes: ServerResponse): Promise<void>;
+/**
+ * Invoke a matched route's handler, binding path params BY NAME.
+ *
+ * A handler declares whatever it needs - `(id, request, response)`, `(req, res)`,
+ * or nothing - and each parameter is resolved by its name: a path param wins,
+ * then `request`/`req`, then the response.
+ */
+/**
+ * Resolve a handler's argument list to `[reqOrParam, resOrParam, ...]` values.
+ *
+ * By-name path preserved (route-param names, `req`/`request`, `res`/`response`)
+ * so existing code keeps its DX. Any remaining unmatched name falls back to
+ * POSITIONAL binding: first unmatched -> request, rest -> response. That makes
+ * dispatch bundler-safe by construction: Bun `--compile` and terser/esbuild
+ * identifier-mangling rename `(req, res)` to `(req2, r$0)` — the by-name path
+ * misses, the positional fallback catches, and the handler still receives the
+ * request as its first argument. Fixes #56.
+ *
+ * Exported so the regression test can pin the behaviour directly, without a
+ * live HTTP server.
+ */
+export declare function resolveHandlerArgs(handler: unknown, req: Tina4Request, res: Tina4Response, routeParams: Record<string, unknown>): unknown[];
 /**
  * Everything one request's dispatch needs beyond req/res: the resolved
  * router, middleware chain, filesystem roots and template engine a boot