typespec-hono 0.5.0 → 0.6.0

package/dist/src/app.js

@@ -600,7 +600,7 @@ securityFor) {
             "\t\t\t},",
             "\t\t)",
         ].join("\n");
-        return { target, text };
+        return { target, text, headOnly };
     });
     /**
      * Every identifier this file names, imported from the module that declares it.
@@ -608,8 +608,21 @@ securityFor) {
      * **Derived from what the rendered text actually references, not from what was available.** An
      * unused import fails the lint a generated file has to pass like any other, and a missing one is a
      * file that does not compile. Both have happened.
+     *
+     * **The text is TOKENISED and compared by equality, never matched name by name.** It used to build
+     * `new RegExp("\\b" + identifier + "\\b")` per name, and that was wrong twice over for any
+     * identifier containing a `$`, which TypeSpec permits in a model or operation name: `$` is an
+     * anchor in a regular expression, and escaping it alone does not help because `\b` is a WORD
+     * boundary and `$` is not a word character, so `\b\$select\b` cannot match either. Measured on
+     * `op list$Items(...): Item$Ref[]`, every identifier reported ABSENT, the whole
+     * `./schemas.gen.js` import was dropped, and the emitted file failed with four
+     * `TS2304: Cannot find name`. No diagnostic anywhere.
+     *
+     * Splitting on the language's own identifier rule and testing membership has neither failure: no
+     * metacharacter can be misread, and `Foo` cannot match `FooExtra`.
      */
     const rendered = [...registrations.map((r) => r.text), ...methods, ...aliases].join("\n");
+    const mentioned = new Set(rendered.match(/[A-Za-z_$][A-Za-z0-9_$]*/g) ?? []);
     const referenced = [
         ...new Set(entries.flatMap((entry) => [
             entry.names.path,
@@ -620,7 +633,7 @@ securityFor) {
             entry.names.responses,
         ].filter((name) => name !== undefined))),
     ]
-        .filter((identifier) => new RegExp(`\\b${identifier}\\b`).test(rendered))
+        .filter((identifier) => mentioned.has(identifier))
         .toSorted();
     const imports = referenced.length === 0
         ? ""
@@ -670,15 +683,24 @@ securityFor) {
     // Imported only where a route actually negotiates: an unused import fails the repo's own lint.
     const negotiates = [...grouped.values()].some((group) => group.length > 1);
     // Same rule: imported only where a HEAD operation stands alone on its path.
-    const guardsHead = registrations.some((registration) => registration.text.includes("headOnly,"));
+    const guardsHead = registrations.some((registration) => registration.headOnly);
     /**
-     * Read from the entries rather than from the rendered text, which the two lines above still do.
+     * **Which runtime imports to write is read from the DATA, never from the rendered text.**
      *
-     * **Matching a substring of generated output is how this import went missing once already.** It
-     * tested for `byContentType([`, the emitted call gained arguments before its bracket, the substring
-     * stopped matching, the import stopped being written, and the emitted module threw
+     * Matching a substring of generated output is how one of these went missing already: it tested for
+     * `byContentType([`, the emitted call gained arguments before its bracket, the substring stopped
+     * matching, the import stopped being written, and the emitted module threw
      * `ReferenceError: byContentType is not defined` at registration. Nothing in the emitter objected,
      * because the check was a string about a string.
+     *
+     * `guardsHead` above had the same shape, and the sibling library had it in a worse place, deciding
+     * whether a parameter gets a wire decoder by `declared.startsWith("z.number()")`. A literal union
+     * (`@query size: 10 | 25 | 50`) begins with neither prefix, so every conformant caller of that
+     * parameter got a 400 that no document comparison could see.
+     *
+     * The rendered text is still read to decide which VALIDATOR identifiers to import, and that one is
+     * safe in a way these are not: an identifier absent from the text is genuinely not needed, so the
+     * check cannot be wrong in the direction that breaks a build.
      */
     const dispatchesBody = entries.some((entry) => entry.dispatched !== undefined);
     const runtimeModule = JSON.stringify(emitted.options.runtimeModule);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-hono",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "TypeSpec emitter: generate a Hono server, and the Zod validators it enforces, from an HTTP service definition, agreeing with the OpenAPI document @typespec/openapi3 publishes from the same source.",
   "keywords": [
     "cloudflare-workers",
@@ -44,7 +44,7 @@
     "provenance": true
   },
   "dependencies": {
-    "typespec-http-zod": "^0.5.0"
+    "typespec-http-zod": "^0.6.0"
   },
   "devDependencies": {
     "@hono/zod-openapi": "^1.4.0",