@nestia/sdk 12.0.0 → 13.0.0

package/src/generates/internal/SdkTypeProgrammer.ts

@@ -18,6 +18,7 @@ import {
   sizeOf,
 } from "../../internal/legacy";
 import { INestiaProject } from "../../structures/INestiaProject";
+import { StringUtil } from "../../utils/StringUtil";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkTypeTagProgrammer } from "./SdkTypeTagProgrammer";
@@ -53,13 +54,12 @@ export namespace SdkTypeProgrammer {
         union.push(write_array(project)(importer)(array as MetadataArray));
       for (const object of meta.objects) {
         const target = object.type as MetadataObjectType;
-        if (
-          target.name === "object" ||
-          target.name === "__type" ||
-          target.name.startsWith("__type.") ||
-          target.name === "__object" ||
-          target.name.startsWith("__object.")
-        )
+        // One definition of "this type has no name to reference". This was a
+        // second copy of `StringUtil.isImplicit`, and the copies drifted: only
+        // the dotted spelling was listed here, so a duplicated anonymous type
+        // -- `__type-o1` under typia's current separator -- was referenced as a
+        // module that the declaration side had correctly refused to write.
+        if (StringUtil.isImplicit(target.name))
           union.push(write_object(project)(importer)(target));
         else union.push(writeAlias(project)(importer)(target));
       }
@@ -301,7 +301,13 @@ export namespace SdkTypeProgrammer {
     (importer: ImportDictionary) =>
     (meta: MetadataAliasType | MetadataObjectType): TypeNode => {
       importInternalFile(project)(importer)(meta.name);
-      return factory.createTypeReferenceNode(meta.name);
+      // The reference has to spell the accessor path the declaration was
+      // written under, not the raw metadata name: a duplicated name carries
+      // typia's `-o<counter>` marker, which declares as a namespace member and
+      // therefore refers as `IDirectory.o1`.
+      return factory.createTypeReferenceNode(
+        StringUtil.accessorsOf(meta.name).join("."),
+      );
     };
 
   const write_native = (name: string): TypeNode =>
@@ -377,12 +383,14 @@ const importInternalFile =
   (project: INestiaProject) =>
   (importer: ImportDictionary) =>
   (name: string) => {
-    const top: string = name.split(".")[0]!;
+    // The file is named after the first accessor, so a duplicated name lands
+    // in its base type's file rather than inventing `IDirectory-o1.ts`.
+    const top: string = StringUtil.accessorsOf(name)[0]!;
     if (importer.file === `${project.config.output}/structures/${top}.ts`)
       return;
     importer.internal({
       declaration: true,
-      file: `${project.config.output}/structures/${name.split(".")[0]}`,
+      file: `${project.config.output}/structures/${top}`,
       type: "element",
       name: top,
     });

package/src/generates/internal/SdkWebSocketCloneProgrammer.ts

@@ -14,9 +14,10 @@ export namespace SdkWebSocketCloneProgrammer {
     for (const route of app.routes)
       if (route.protocol === "websocket")
         for (const imp of route.imports)
-          for (const name of imp.elements) {
-            if (await clone(ctx)(imp.file, name))
-              cloned.add(importKey(imp.file, name));
+          for (const local of imp.elements) {
+            const imported: string = imp.elementAliases?.[local] ?? local;
+            if (await clone(ctx)(imp.file, imported))
+              cloned.add(importKey(imp.file, imported));
           }
     return cloned;
   };

package/src/generates/internal/SwaggerOperationComposer.ts

@@ -1,8 +1,8 @@
-import { MetadataSchema } from "../../internal/legacy";
 import { OpenApi } from "@typia/interface";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { SecurityAnalyzer } from "../../analyses/SecurityAnalyzer";
+import { MetadataSchema } from "../../internal/legacy";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { SwaggerDescriptionComposer } from "./SwaggerDescriptionComposer";
 import { SwaggerOperationParameterComposer } from "./SwaggerOperationParameterComposer";
@@ -99,13 +99,7 @@ export namespace SwaggerOperationComposer {
           }),
         )
         .flat(),
-      requestBody: props.route.body
-        ? SwaggerOperationParameterComposer.body({
-            schema: props.schema(props.route.body.metadata)!,
-            jsDocTags: props.route.jsDocTags,
-            parameter: props.route.body,
-          })
-        : undefined,
+      requestBody: writeRequestBody(props),
       responses: SwaggerOperationResponseComposer.compose({
         schema: props.schema,
         route: props.route,
@@ -117,3 +111,41 @@ export namespace SwaggerOperationComposer {
     };
   };
 }
+
+/**
+ * Compose an operation's `requestBody`, or omit it when the body has no shape.
+ *
+ * `props.schema` looks the metadata up in what `SwaggerGenerator.compose`
+ * collected, and that collection drops metadata of size zero -- so a `void`,
+ * `undefined` or `never` body is absent from it and the lookup answers
+ * `undefined`. The call site used to assert the result non-null, which turned a
+ * body with nothing to describe into `content: { "application/json": {} }`: a
+ * media type that says "send me JSON" and then declines to say what JSON.
+ *
+ * The Request Body Object's `content` is required by the specification, so the
+ * honest document for such a route is not a `requestBody` with an empty
+ * `content` -- it is no `requestBody`, which is also what the endpoint
+ * accepts.
+ *
+ * Deliberately not `composeContent`, which decides the same question for
+ * responses. The two rules differ and `@typia/utils`' Swagger 2.0 downgrader is
+ * where that is visible: a response is described by a schema _or_ an example,
+ * while a request body needs the schema -- `{ example }` alone is refused with
+ * `request body examples are not representable`, with or without one. Sharing a
+ * helper across two rules that disagree would trade one defect for another.
+ */
+const writeRequestBody = (props: {
+  schema: (metadata: MetadataSchema) => OpenApi.IJsonSchema | undefined;
+  route: ITypedHttpRoute;
+}): OpenApi.IOperation.IRequestBody | undefined => {
+  if (props.route.body === null) return undefined;
+  const schema: OpenApi.IJsonSchema | undefined = props.schema(
+    props.route.body.metadata,
+  );
+  if (schema === undefined) return undefined;
+  return SwaggerOperationParameterComposer.body({
+    schema,
+    jsDocTags: props.route.jsDocTags,
+    parameter: props.route.body,
+  });
+};

package/src/generates/internal/SwaggerOperationResponseComposer.ts

@@ -16,13 +16,12 @@ export namespace SwaggerOperationResponseComposer {
     for (const [status, error] of Object.entries(props.route.exceptions))
       output[status] = {
         description: error.description ?? undefined,
-        content: {
-          "application/json": {
-            schema: props.schema(error.metadata),
-            example: error.example,
-            examples: error.examples,
-          },
-        },
+        content: composeContent({
+          contentType: "application/json",
+          schema: props.schema(error.metadata),
+          example: error.example,
+          examples: error.examples,
+        }),
       };
 
     // FROM COMMENTS
@@ -52,11 +51,17 @@ export namespace SwaggerOperationResponseComposer {
       else if (oldbie === undefined)
         output[status] = {
           description: description,
-          content: {
-            "application/json": {
-              schema: {},
-            },
-          },
+          // The `{}` schema is what an undescribed payload looks like: the tag
+          // names a status and nothing about its body, so the response says a
+          // body exists without constraining it. That is a description, and it
+          // goes through the same helper as every other response rather than
+          // being the one place that still writes a media type by hand.
+          content: composeContent({
+            contentType: "application/json",
+            schema: {},
+            example: undefined,
+            examples: undefined,
+          }),
         };
     }
 
@@ -77,26 +82,67 @@ export namespace SwaggerOperationResponseComposer {
       description: props.route.success.encrypted
         ? `${warning.get(!!description, props.route.method)}${description ?? ""}`
         : (description ?? ""),
-      content: props.route.success.contentType
-        ? {
-            [props.route.success.contentType]: {
-              schema: props.route.success.binary
-                ? {
-                    format: "binary",
-                    type: "string",
-                  }
-                : props.schema(props.route.success.metadata),
-              example: props.route.success.example,
-              examples: props.route.success.examples,
-            },
-          }
-        : undefined,
+      content: composeContent({
+        contentType: props.route.success.contentType,
+        schema: props.route.success.binary
+          ? {
+              format: "binary",
+              type: "string",
+            }
+          : props.schema(props.route.success.metadata),
+        example: props.route.success.example,
+        examples: props.route.success.examples,
+      }),
       ...(props.route.success.encrypted ? { "x-nestia-encrypted": true } : {}),
     };
     return output;
   };
 }
 
+/**
+ * Compose a response's `content`, or omit it when the response has no body.
+ *
+ * `content` describes a response body, so it exists exactly when there is one
+ * to describe. A response whose metadata yields no schema -- a `void` return
+ * type, or a `@TypedException<void>` declaring a status that carries no payload
+ * -- has nothing to put under the media type, and writing the media type anyway
+ * says "this endpoint replies with JSON" and then declines to say what the JSON
+ * is: a client generator emits a parse for a body that never arrives, and the
+ * Swagger 2.0 downgrade refuses the whole document because a schemaless
+ * `produces` entry carries no information at all.
+ *
+ * Every response this composer emits goes through here. The success response, a
+ * declared exception, and a `@throws` tag all reach the same media type by the
+ * same route, so a rule applied to one of them leaves the others still emitting
+ * the shape it was written to remove -- which is exactly how the exception
+ * responses survived the fix to the success one.
+ *
+ * The test is what the metadata yields, not how the return type is spelled:
+ * `void`, `undefined` and `never` all describe the same absent body. An example
+ * without a schema still describes a body, so it keeps the entry, and so does
+ * the `{}` schema the `@throws` tag path supplies for an unspecified payload.
+ */
+const composeContent = (props: {
+  contentType: string | null | undefined;
+  schema: OpenApi.IJsonSchema | undefined;
+  example: any;
+  examples: Record<string, any> | undefined;
+}): OpenApi.IOperation.IContent | undefined => {
+  if (!props.contentType) return undefined;
+  const described: boolean =
+    props.schema !== undefined ||
+    props.example !== undefined ||
+    Object.keys(props.examples ?? {}).length !== 0;
+  if (described === false) return undefined;
+  return {
+    [props.contentType]: {
+      schema: props.schema,
+      example: props.example,
+      examples: props.examples,
+    },
+  };
+};
+
 const warning = new VariadicSingleton((described: boolean, method: string) => {
   const summary: string = "Response data have been encrypted.";
   const component: string = `[EncryptedRoute.${StringUtil.capitalize(method)}](https://github.com/samchon/@nestia/core#encryptedroute)`;

package/src/internal/legacy.ts

@@ -12,7 +12,6 @@
 // cross-reference lookups in O(1). Everything else either reads a
 // pre-baked field or short-circuits because typia's compile-time
 // transform already enforces the invariant.
-
 import type {
   IJsonSchemaCollection,
   IMetadataComponents,
@@ -39,16 +38,15 @@ declare module "@typia/interface" {
 /**
  * Plain `IMetadataSchema` augmented with the fields the nestia transform
  * pre-bakes. `size`, `name`, and `empty` replace the methods the legacy
- * `MetadataSchema` class exposed; `jsonSchema` is the OpenAPI 3.1
- * conversion typia's Go-side produces but does not expose to JS at
- * runtime.
+ * `MetadataSchema` class exposed; `jsonSchema` is the OpenAPI 3.1 conversion
+ * typia's Go-side produces but does not expose to JS at runtime.
  *
  * Fields are declared optional so that nested `IMetadataSchema` values
- * (`metadata.rest`, `metadata.escaped.original`, `IObjectType.value`,
- * …) — which are not top-level route inputs and therefore do not carry
- * the pre-baked overlay — still satisfy the type when passed through
- * legacy utilities. The utilities read the fields via the optional
- * accessor and fall back when absent.
+ * (`metadata.rest`, `metadata.escaped.original`, `IObjectType.value`, …) —
+ * which are not top-level route inputs and therefore do not carry the pre-baked
+ * overlay — still satisfy the type when passed through legacy utilities. The
+ * utilities read the fields via the optional accessor and fall back when
+ * absent.
  */
 export interface IReflectMetadata extends IMetadataSchema {
   size?: number;
@@ -64,9 +62,9 @@ export interface IReflectJsonSchema {
 }
 
 /**
- * Cross-reference dictionary produced by `MetadataComponents.from`. Each
- * map is keyed by the entry's `.name`, matching the lookup pattern the
- * legacy `MetadataComponents.dictionary` getter offered.
+ * Cross-reference dictionary produced by `MetadataComponents.from`. Each map is
+ * keyed by the entry's `.name`, matching the lookup pattern the legacy
+ * `MetadataComponents.dictionary` getter offered.
  */
 export interface IMetadataDictionary {
   objects: Map<string, IMetadataSchema.IObjectType>;
@@ -89,9 +87,9 @@ export type MetadataTupleType = IMetadataSchema.ITupleType;
 export type MetadataObjectType = IMetadataSchema.IObjectType;
 export type MetadataAtomic = IMetadataSchema.IAtomic;
 /**
- * Flattened constant-value shape: typia v13 splits `IConstant.IValue<T>` by
- * the atomic discriminator, but sdk's literal writer just needs the runtime
- * `value` payload, so collapse the union to a single ergonomic shape.
+ * Flattened constant-value shape: typia v13 splits `IConstant.IValue<T>` by the
+ * atomic discriminator, but sdk's literal writer just needs the runtime `value`
+ * payload, so collapse the union to a single ergonomic shape.
  */
 export interface MetadataConstantValue {
   value: string | number | bigint | boolean;
@@ -101,12 +99,12 @@ export type MetadataEscaped = IMetadataSchema.IEscaped;
 export type MetadataProperty = IMetadataSchema.IProperty;
 
 /**
- * Reference to a named array/tuple/object/alias type. typia v13's
- * plain `IReference` carries only the symbolic `name` + tags; the
- * legacy class additionally exposed `.type` as a getter that resolved
- * against the dictionary. `MetadataSchema.from` walks the metadata
- * tree once and attaches the resolved `.type` field so downstream
- * sdk code can keep its `ref.type` access pattern.
+ * Reference to a named array/tuple/object/alias type. typia v13's plain
+ * `IReference` carries only the symbolic `name` + tags; the legacy class
+ * additionally exposed `.type` as a getter that resolved against the
+ * dictionary. `MetadataSchema.from` walks the metadata tree once and attaches
+ * the resolved `.type` field so downstream sdk code can keep its `ref.type`
+ * access pattern.
  */
 export type MetadataArray = IMetadataSchema.IReference & {
   type: MetadataArrayType;
@@ -138,10 +136,10 @@ export const emptyOf = (m: IMetadataSchema): boolean =>
   (m as IReflectMetadata).empty ?? false;
 
 /**
- * Equivalent of the legacy `MetadataSchema.isSoleLiteral()` method:
- * `true` when the schema represents exactly one constant literal value
- * and nothing else. Used by sdk's type printer to fall back to literal
- * emission instead of a union.
+ * Equivalent of the legacy `MetadataSchema.isSoleLiteral()` method: `true` when
+ * the schema represents exactly one constant literal value and nothing else.
+ * Used by sdk's type printer to fall back to literal emission instead of a
+ * union.
  */
 export const isSoleLiteralOf = (m: IMetadataSchema): boolean => {
   if (m.any) return false;
@@ -184,11 +182,11 @@ export namespace MetadataComponents {
 
 export namespace MetadataSchema {
   /**
-   * Walks the metadata tree and attaches the resolved `.type` field to
-   * every `IReference` it encounters, using the supplied dictionary as
-   * the lookup index. This is idempotent — references whose `.type`
-   * has already been resolved are left alone — and mutates the input,
-   * matching the in-place resolution model `@typia/core` 12.x used.
+   * Walks the metadata tree and attaches the resolved `.type` field to every
+   * `IReference` it encounters, using the supplied dictionary as the lookup
+   * index. This is idempotent — references whose `.type` has already been
+   * resolved are left alone — and mutates the input, matching the in-place
+   * resolution model `@typia/core` 12.x used.
    */
   export const from = (
     plain: IMetadataSchema,
@@ -202,12 +200,11 @@ export namespace MetadataSchema {
 }
 
 /**
- * The walk tracks visited *targets* (the IObjectType / IArrayType / …
- * instances reached through the dictionary), not the wrapper schemas.
- * Wrapper schemas are reconstructed on the JS side and are not shared
- * across recursive references, so a `visited<IMetadataSchema>` set never
- * matches and the walk would recurse forever on cycles like
- * `interface Node { children: Node[] }`.
+ * The walk tracks visited _targets_ (the IObjectType / IArrayType / … instances
+ * reached through the dictionary), not the wrapper schemas. Wrapper schemas are
+ * reconstructed on the JS side and are not shared across recursive references,
+ * so a `visited<IMetadataSchema>` set never matches and the walk would recurse
+ * forever on cycles like `interface Node { children: Node[] }`.
  */
 const attachTypes = (
   schema: IMetadataSchema | null | undefined,
@@ -222,7 +219,8 @@ const attachTypes = (
     for (const elem of target.elements) attachTypes(elem, dict, visited);
   });
   attachReferences(schema.objects, dict.objects, visited, (target) => {
-    for (const prop of target.properties) attachTypes(prop.value, dict, visited);
+    for (const prop of target.properties)
+      attachTypes(prop.value, dict, visited);
   });
   attachReferences(schema.aliases, dict.aliases, visited, (target) =>
     attachTypes(target.value, dict, visited),
@@ -254,8 +252,7 @@ const attachReferences = <Target extends { name: string }>(
     const mutable = ref as IMetadataSchema.IReference & { type?: Target };
     if (mutable.type === undefined) {
       const target = index.get(ref.name);
-      if (target !== undefined)
-        (mutable as { type?: Target }).type = target;
+      if (target !== undefined) (mutable as { type?: Target }).type = target;
     }
     if (mutable.type !== undefined && visited.has(mutable.type) === false) {
       visited.add(mutable.type);
@@ -290,13 +287,12 @@ export namespace MetadataFactory {
 
   /**
    * Walks the metadata tree once, invoking the provided validator on each
-   * visited node, and accumulates the produced messages into `IError`
-   * entries. The walk skips back-edges through references so cyclic
-   * structures terminate. This is a faithful reimplementation of the
-   * legacy `@typia/core` walker, kept lean: the typia native transform
-   * has already validated structural invariants, so the validator is only
-   * called for SDK-side policy checks (JSON-serializability, query/header
-   * atomic-only rules, …).
+   * visited node, and accumulates the produced messages into `IError` entries.
+   * The walk skips back-edges through references so cyclic structures
+   * terminate. This is a faithful reimplementation of the legacy `@typia/core`
+   * walker, kept lean: the typia native transform has already validated
+   * structural invariants, so the validator is only called for SDK-side policy
+   * checks (JSON-serializability, query/header atomic-only rules, …).
    */
   export const validate = (props: {
     options?: unknown;
@@ -315,39 +311,49 @@ export namespace MetadataFactory {
       if (messages.length)
         errors.push({ name: nameOf(metadata), explore, messages });
       for (const obj of metadata.objects) {
-        const type = (obj as IMetadataSchema.IReference & {
-          type?: IMetadataSchema.IObjectType;
-        }).type;
+        const type = (
+          obj as IMetadataSchema.IReference & {
+            type?: IMetadataSchema.IObjectType;
+          }
+        ).type;
         if (type === undefined || visited.has(type)) continue;
         visited.add(type);
         for (const prop of type.properties)
           visit(prop.value, {
             object: type,
-            property: nameOf(prop.key) || String(prop.key.constants[0]?.values[0]?.value ?? ""),
+            property:
+              nameOf(prop.key) ||
+              String(prop.key.constants[0]?.values[0]?.value ?? ""),
             parameter: null,
             output: explore.output,
           });
       }
       for (const arr of metadata.arrays) {
-        const type = (arr as IMetadataSchema.IReference & {
-          type?: IMetadataSchema.IArrayType;
-        }).type;
+        const type = (
+          arr as IMetadataSchema.IReference & {
+            type?: IMetadataSchema.IArrayType;
+          }
+        ).type;
         if (type === undefined || visited.has(type)) continue;
         visited.add(type);
         visit(type.value, explore);
       }
       for (const tuple of metadata.tuples) {
-        const type = (tuple as IMetadataSchema.IReference & {
-          type?: IMetadataSchema.ITupleType;
-        }).type;
+        const type = (
+          tuple as IMetadataSchema.IReference & {
+            type?: IMetadataSchema.ITupleType;
+          }
+        ).type;
         if (type === undefined || visited.has(type)) continue;
         visited.add(type);
         for (const elem of type.elements) visit(elem, explore);
       }
       for (const alias of metadata.aliases) {
-        const type = (alias as IMetadataSchema.IReference & {
-          type?: IMetadataSchema.IAliasType;
-        }).type;
+        const type = (
+          alias as IMetadataSchema.IReference & {
+            type?: IMetadataSchema.IAliasType;
+          }
+        ).type;
         if (type === undefined || visited.has(type)) continue;
         visited.add(type);
         visit(type.value, explore);
@@ -370,10 +376,10 @@ export namespace MetadataFactory {
 export namespace JsonMetadataFactory {
   /**
    * Rejects metadata that cannot be losslessly JSON-serialized. The typia
-   * native runtime already screens out most structurally invalid types, so
-   * this only adds the JSON-policy bans the legacy `@typia/core` walker
-   * enforced — bare `bigint` payloads, function-typed properties, and
-   * `Map` / `Set` containers that have no canonical JSON representation.
+   * native runtime already screens out most structurally invalid types, so this
+   * only adds the JSON-policy bans the legacy `@typia/core` walker enforced —
+   * bare `bigint` payloads, function-typed properties, and `Map` / `Set`
+   * containers that have no canonical JSON representation.
    */
   export const validate: MetadataFactory.Validator = (props) => {
     const messages: string[] = [];
@@ -414,12 +420,12 @@ export namespace JsonSchemasProgrammer {
   /**
    * Consumes the per-metadata `jsonSchema` field the nestia transform
    * pre-bakes. Top-level route metadata (success / parameter / exception)
-   * always carries a baked schema; for nested metadata (object property
-   * values reached by the decomposed-query path), the bake is absent and
-   * this function falls back to a minimal JS-side converter that handles
-   * the schema shapes decompose actually emits — atomics, constants,
-   * templates, arrays of those, named references — without re-implementing
-   * the typia native programmer wholesale.
+   * always carries a baked schema; for nested metadata (object property values
+   * reached by the decomposed-query path), the bake is absent and this function
+   * falls back to a minimal JS-side converter that handles the schema shapes
+   * decompose actually emits — atomics, constants, templates, arrays of those,
+   * named references — without re-implementing the typia native programmer
+   * wholesale.
    */
   export const writeSchemas = (props: {
     version: "3.0" | "3.1";
@@ -462,12 +468,16 @@ const schemaFromMetadata = (m: IMetadataSchema): OpenApi.IJsonSchema => {
     void tpl;
   }
   for (const arr of m.arrays) {
-    const inner = (arr as IMetadataSchema.IReference & {
-      type?: IMetadataSchema.IArrayType;
-    }).type;
+    const inner = (
+      arr as IMetadataSchema.IReference & {
+        type?: IMetadataSchema.IArrayType;
+      }
+    ).type;
     union.push({
       type: "array",
-      items: inner ? schemaFromMetadata(inner.value) : ({} as OpenApi.IJsonSchema),
+      items: inner
+        ? schemaFromMetadata(inner.value)
+        : ({} as OpenApi.IJsonSchema),
     } as unknown as OpenApi.IJsonSchema);
   }
   for (const obj of m.objects)

package/src/structures/IReflectHttpOperationException.ts

@@ -1,6 +1,6 @@
-import { MetadataFactory } from "../internal/legacy";
 import { IMetadataComponents, IMetadataSchema } from "@typia/interface";
 
+import { MetadataFactory } from "../internal/legacy";
 import { IReflectType } from "./IReflectType";
 
 export interface IReflectHttpOperationException {

package/src/structures/IReflectHttpOperationParameter.ts

@@ -1,10 +1,10 @@
-import { MetadataFactory } from "../internal/legacy";
 import {
   IJsDocTagInfo,
   IMetadataComponents,
   IMetadataSchema,
 } from "@typia/interface";
 
+import { MetadataFactory } from "../internal/legacy";
 import { IReflectType } from "./IReflectType";
 
 export type IReflectHttpOperationParameter =

package/src/structures/IReflectImport.ts

@@ -3,4 +3,6 @@ export interface IReflectImport {
   asterisk: string | null;
   default: string | null;
   elements: string[];
+  /** Maps a local named binding to the name exported by its source module. */
+  elementAliases?: Record<string, string>;
 }

package/src/structures/ITypedApplication.ts

@@ -1,5 +1,4 @@
 import { IMetadataDictionary } from "../internal/legacy";
-
 import { INestiaProject } from "./INestiaProject";
 import { ITypedHttpRoute } from "./ITypedHttpRoute";
 import { ITypedMcpRoute } from "./ITypedMcpRoute";

package/src/structures/ITypedHttpRouteException.ts

@@ -1,5 +1,4 @@
 import { MetadataSchema } from "../internal/legacy";
-
 import { IReflectType } from "./IReflectType";
 
 export interface ITypedHttpRouteException {

package/src/structures/ITypedHttpRouteParameter.ts

@@ -1,6 +1,6 @@
-import { MetadataSchema } from "../internal/legacy";
 import { IJsDocTagInfo } from "typia";
 
+import { MetadataSchema } from "../internal/legacy";
 import { IReflectType } from "./IReflectType";
 
 export type ITypedHttpRouteParameter =

package/src/utils/StringUtil.ts

@@ -7,11 +7,51 @@ export namespace StringUtil {
     (change: string): string =>
       keep.includes(change) ? escapeDuplicate(keep)(`_${change}`) : change;
 
-  export const isImplicit = (str: string) =>
-    str === "object" ||
+  /**
+   * The marker names typia gives a type that has no identity of its own: an
+   * anonymous object literal, and the same literal after a duplicate id was
+   * minted for it.
+   *
+   * One definition because the spellings drift. typia qualifies with `.` and
+   * disambiguates a duplicate with `-o<counter>`, so the same anonymous type
+   * reads `__type`, `__type.o1` or `__type-o1` depending on the release and on
+   * whether its name collided. Three call sites carried their own copy of this
+   * list, only one of them learned the `-` spelling, and the two that did not
+   * declared and referenced modules that do not exist.
+   */
+  export const isAnonymous = (str: string): boolean =>
     str === "__type" ||
     str === "__object" ||
     str.startsWith("__type.") ||
     str.startsWith("__object.") ||
-    str.includes("readonly [");
+    str.startsWith("__type-") ||
+    str.startsWith("__object-");
+
+  export const isImplicit = (str: string) =>
+    str === "object" || isAnonymous(str) || str.includes("readonly [");
+
+  /**
+   * Split a typia metadata name into the accessor path a generated SDK declares
+   * it under.
+   *
+   * Typia separates a qualified name with `.` and a _duplicated_ name from its
+   * disambiguating counter with a trailing `-o<counter>`
+   * (`MetadataCollection.composeName`). Those are different relations and only
+   * the first is a namespace boundary -- which is exactly why typia stopped
+   * spelling the second one with a dot, where the two were indistinguishable.
+   *
+   * A duplicate still has to become some declarable identifier, and the counter
+   * is rendered as the last accessor: `IDirectory-o1` declares as `namespace
+   * IDirectory { type o1 }`, byte-identical to what the previous
+   * `IDirectory.o1` spelling produced. Reading the marker here rather than
+   * guessing at the name is what the new separator makes possible -- `-` cannot
+   * occur in a qualified name, so unlike the old spelling this cannot be
+   * confused with one.
+   */
+  export const accessorsOf = (name: string): string[] => {
+    const duplicated: RegExpMatchArray | null = name.match(/^(.+)-o(\d+)$/);
+    return duplicated === null
+      ? name.split(".")
+      : [...duplicated[1]!.split("."), `o${duplicated[2]!}`];
+  };
 }