typia 15.0.0 → 15.1.0

package/src/protobuf.ts

@@ -15,12 +15,12 @@ import { NoTransformConfigurationError } from "./transformers/NoTransformConfigu
 /**
  * Generates Protocol Buffer message schema.
  *
- * @danger You must configure the generic argument `T`
+ * @danger You must configure the generic argument `_T`
  */
 export function message(): never;
 
 /**
- * Generates Protocol Buffer message schema for type `T`.
+ * Generates Protocol Buffer message schema for type `_T`.
  *
  * Creates a `.proto` message definition string from a TypeScript type. Use for
  * sharing schemas with other languages/frameworks.
@@ -28,11 +28,13 @@ export function message(): never;
  * Protocol Buffer has limited expressiveness compared to TypeScript.
  * Incompatible types cause compilation errors.
  *
- * @template T Target type
+ * @template _T Target type
+ *
  * @returns Protocol Buffer message schema string
+ *
  * @see https://typia.io/docs/protobuf/message/#restrictions
  */
-export function message<T>(): string;
+export function message<_T>(): string;
 
 /** @internal */
 export function message(): never {
@@ -66,7 +68,9 @@ export function decode(input: Uint8Array): never;
  * like `number & Minimum<7>`, not structural type safety.
  *
  * @template T Target type
+ *
  * @param input Protocol Buffer binary data
+ *
  * @returns Decoded value of type `T`
  */
 export function decode<T>(input: Uint8Array): Resolved<T>;
@@ -103,10 +107,13 @@ export function assertDecode(
  * - {@link validateDecode} — Returns detailed validation errors
  *
  * @template T Target type
+ *
  * @param input Protocol Buffer binary data
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Decoded value of type `T`
+ *
  * @throws {TypeGuardError} When custom tag validation fails
  */
 export function assertDecode<T>(
@@ -142,7 +149,9 @@ export function isDecode(input: Uint8Array): never;
  * - {@link validateDecode} — Returns detailed validation errors
  *
  * @template T Target type
+ *
  * @param input Protocol Buffer binary data
+ *
  * @returns Decoded value of type `T`, or `null` if invalid
  */
 export function isDecode<T>(input: Uint8Array): Resolved<T> | null;
@@ -177,7 +186,9 @@ export function validateDecode(input: Uint8Array): never;
  * - {@link isDecode} — Returns `null` instead of error details
  *
  * @template T Target type
+ *
  * @param input Protocol Buffer binary data
+ *
  * @returns Validation result containing decoded value or errors
  */
 export function validateDecode<T>(input: Uint8Array): IValidation<Resolved<T>>;
@@ -205,8 +216,11 @@ export function validateDecode(): never {
  * Incompatible types cause compilation errors.
  *
  * @template T Type of input value
+ *
  * @param input Value to encode
+ *
  * @returns Protocol Buffer binary data
+ *
  * @see https://typia.io/docs/protobuf/message/#restrictions
  */
 export function encode<T>(input: T): Uint8Array;
@@ -232,11 +246,15 @@ export function encode(): never {
  * Incompatible types cause compilation errors.
  *
  * @template T Type of input value
+ *
  * @param input Value to encode
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Protocol Buffer binary data
+ *
  * @throws {TypeGuardError} When input doesn't conform to type `T`
+ *
  * @see https://typia.io/docs/protobuf/message/#restrictions
  */
 export function assertEncode<T>(
@@ -245,7 +263,7 @@ export function assertEncode<T>(
 ): Uint8Array;
 
 /** @internal */
-export function assertEncode<T>(
+export function assertEncode<_T>(
   input: unknown,
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): Uint8Array;
@@ -270,14 +288,17 @@ export function assertEncode(): never {
  * Incompatible types cause compilation errors.
  *
  * @template T Type of input value
+ *
  * @param input Value to encode
+ *
  * @returns Protocol Buffer binary data, or `null` if invalid
+ *
  * @see https://typia.io/docs/protobuf/message/#restrictions
  */
 export function isEncode<T>(input: T): Uint8Array | null;
 
 /** @internal */
-export function isEncode<T>(input: unknown): Uint8Array | null;
+export function isEncode<_T>(input: unknown): Uint8Array | null;
 
 /** @internal */
 export function isEncode(): never {
@@ -301,14 +322,17 @@ export function isEncode(): never {
  * Incompatible types cause compilation errors.
  *
  * @template T Type of input value
+ *
  * @param input Value to encode
+ *
  * @returns Validation result containing binary data or errors
+ *
  * @see https://typia.io/docs/protobuf/message/#restrictions
  */
 export function validateEncode<T>(input: T): IValidation<Uint8Array>;
 
 /** @internal */
-export function validateEncode<T>(input: unknown): IValidation<Uint8Array>;
+export function validateEncode<_T>(input: unknown): IValidation<Uint8Array>;
 
 /** @internal */
 export function validateEncode(): never {
@@ -329,6 +353,7 @@ export function createDecode(): never;
  * Creates reusable {@link decode} function.
  *
  * @template T Target type
+ *
  * @returns Reusable decoder function
  */
 export function createDecode<T>(): (input: Uint8Array) => Resolved<T>;
@@ -349,6 +374,7 @@ export function createIsDecode(): never;
  * Creates reusable {@link isDecode} function.
  *
  * @template T Target type
+ *
  * @returns Reusable decoder function
  */
 export function createIsDecode<T>(): (input: Uint8Array) => Resolved<T> | null;
@@ -371,8 +397,10 @@ export function createAssertDecode(
  * Creates reusable {@link assertDecode} function.
  *
  * @template T Target type
+ *
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Reusable decoder function
  */
 export function createAssertDecode<T>(
@@ -401,6 +429,7 @@ export function createValidateDecode(): never;
  * Creates reusable {@link validateDecode} function.
  *
  * @template T Target type
+ *
  * @returns Reusable decoder function
  */
 export function createValidateDecode<T>(): (
@@ -425,6 +454,7 @@ export function createEncode(): never;
  * Creates reusable {@link encode} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable encoder function
  */
 export function createEncode<T>(): (input: T) => Uint8Array;
@@ -445,6 +475,7 @@ export function createIsEncode(): never;
  * Creates reusable {@link isEncode} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable encoder function
  */
 export function createIsEncode<T>(): (input: T) => Uint8Array | null;
@@ -467,8 +498,10 @@ export function createAssertEncode(
  * Creates reusable {@link assertEncode} function.
  *
  * @template T Type of input value
+ *
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
+ *
  * @returns Reusable encoder function
  */
 export function createAssertEncode<T>(
@@ -497,6 +530,7 @@ export function createValidateEncode(): never;
  * Creates reusable {@link validateEncode} function.
  *
  * @template T Type of input value
+ *
  * @returns Reusable encoder function
  */
 export function createValidateEncode<T>(): (

package/src/reflect.ts

@@ -9,7 +9,7 @@ import { NoTransformConfigurationError } from "./transformers/NoTransformConfigu
 /**
  * Generates metadata schemas for multiple types.
  *
- * @danger You must configure the generic argument `Types`
+ * @danger You must configure the generic argument `_Types`
  */
 export function schemas(): never;
 
@@ -20,10 +20,11 @@ export function schemas(): never;
  * the tuple. Collection types (Array, Tuple, Object) are stored in
  * `components`. Alias types are stored in `aliases`.
  *
- * @template Types Tuple of target types
+ * @template _Types Tuple of target types
+ *
  * @returns Metadata schema collection
  */
-export function schemas<Types extends unknown[]>(): IMetadataSchemaCollection;
+export function schemas<_Types extends unknown[]>(): IMetadataSchemaCollection;
 
 /** @internal */
 export function schemas(): never {
@@ -33,7 +34,7 @@ export function schemas(): never {
 /**
  * Generates metadata schema for a single type.
  *
- * @danger You must configure the generic argument `Type`
+ * @danger You must configure the generic argument `_Type`
  */
 export function schema(): never;
 
@@ -42,10 +43,11 @@ export function schema(): never;
  *
  * Creates {@link IMetadataSchemaUnit} containing metadata for the type.
  *
- * @template Type Target type
+ * @template _Type Target type
+ *
  * @returns Metadata schema unit
  */
-export function schema<Type>(): IMetadataSchemaUnit;
+export function schema<_Type>(): IMetadataSchemaUnit;
 
 /** @internal */
 export function schema(): never {
@@ -53,22 +55,23 @@ export function schema(): never {
 }
 
 /**
- * Gets the runtime type name of type `T`.
+ * Gets the runtime type name of type `_T`.
  *
- * @danger You must configure the generic argument `T`
+ * @danger You must configure the generic argument `_T`
  */
 export function name(): never;
 
 /**
- * Gets the runtime type name of type `T`.
+ * Gets the runtime type name of type `_T`.
  *
  * Returns a string representation of the type name.
  *
- * @template T Target type
- * @template Regular If `true`, returns regular (normalized) name
+ * @template _T Target type
+ * @template _Regular If `true`, returns regular (normalized) name
+ *
  * @returns Type name string
  */
-export function name<T, Regular extends boolean = false>(): string;
+export function name<_T, _Regular extends boolean = false>(): string;
 
 /** @internal */
 export function name(): never {
@@ -88,6 +91,7 @@ export function literals(): never;
  * Extracts all members of a union literal type `T` into an array at runtime.
  *
  * @template T Union literal type (e.g., `"A" | "B" | 1`)
+ *
  * @returns Array containing all union members
  */
 export function literals<T extends Atomic.Type | null>(): T[];

package/src/transform.ts

@@ -2,6 +2,23 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import type { ITtscPlugin, ITtscPluginFactoryContext } from "ttsc";
 
+/**
+ * Describe typia's native transform to ttsc.
+ *
+ * Ttsc loads this file as an ES module, where `require` is unavailable, so a
+ * resolver is anchored on the consuming project to find typia's own package
+ * root. The returned descriptor names the plugin and the Go command under
+ * `native/cmd/ttsc-typia`; the transform itself is not written in TypeScript.
+ *
+ * @param context Plugin factory context of ttsc
+ *
+ * @returns Plugin descriptor
+ *
+ * @evidence contracts/common.md#principled-implementation The ttsc loader runs this file as an ES module where `require` is absent, so the function builds a CommonJS resolver anchored at the consuming project and resolves typia's own `package.json`, whose directory holds the native sources; the returned descriptor names the plugin and the Go command directory under `native/cmd/ttsc-typia`.
+ * @evidence contracts/common.md#clear-and-simple-design One function that returns a two-field descriptor and no transformer; the default export repeats the same function for loaders that read it.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The package root comes from the installed typia through the supported resolver and not from path substrings, so it works for npm consumers and workspaces alike; the transform itself stays in Go.
+ * @evidence contracts/common.md#meaningful-documentation A comment explains the purpose, the ESM resolution reason and the descriptor.
+ */
 export function createTtscPlugin(
   context: ITtscPluginFactoryContext,
 ): ITtscPlugin {

package/native/cmd/ttsc-typia/boolean_literal_discriminant_schema_transform_test.go

@@ -1,374 +0,0 @@
-package main
-
-import (
-  "bytes"
-  "os"
-  "os/exec"
-  "path/filepath"
-  "runtime"
-  "strings"
-  "testing"
-)
-
-// TestBooleanLiteralDiscriminantSchemaTransform verifies boolean discriminant
-// constants survive schema transforms.
-//
-// The SDK-facing JSON schema path in #1841 depends on `ok: false` remaining a
-// boolean constant after metadata collection and schema emission. This test
-// runs the native transform and executes the emitted module so a missed
-// transform, a collapsed false branch, or a schema writer regression fails.
-//
-//  1. Transform a fixture containing `reflect.schema`, `json.schema`, and
-//     `json.application` calls over `ok: false | true` output branches.
-//  2. Execute the emitted JavaScript with an empty typia stub, proving the
-//     schema calls were inlined by the transformer.
-//  3. Assert the reflect, JSON schema, and JSON application outputs preserve
-//     the boolean constants on the correct object branches.
-func TestBooleanLiteralDiscriminantSchemaTransform(t *testing.T) {
-  project := booleanLiteralDiscriminantProject(t)
-  js := booleanLiteralDiscriminantTransform(t, project, "js")
-  booleanLiteralDiscriminantRunRuntimeCases(t, project, js)
-}
-
-func booleanLiteralDiscriminantProject(t *testing.T) string {
-  t.Helper()
-  root := booleanLiteralDiscriminantRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "boolean-literal-discriminant-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
-  src := filepath.Join(dir, "src")
-  if err := os.MkdirAll(src, 0o755); err != nil {
-    t.Fatalf("mkdir fixture src: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(booleanLiteralDiscriminantTSConfig), 0o644); err != nil {
-    t.Fatalf("write tsconfig: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(booleanLiteralDiscriminantSource), 0o644); err != nil {
-    t.Fatalf("write source: %v", err)
-  }
-  return dir
-}
-
-func booleanLiteralDiscriminantRepoRoot(t *testing.T) string {
-  t.Helper()
-  _, file, _, ok := runtime.Caller(0)
-  if !ok {
-    t.Fatal("runtime.Caller failed")
-  }
-  dir := filepath.Dir(file)
-  for {
-    if _, err := os.Stat(filepath.Join(dir, "pnpm-workspace.yaml")); err == nil {
-      return dir
-    }
-    next := filepath.Dir(dir)
-    if next == dir {
-      t.Fatalf("repo root not found from %s", file)
-    }
-    dir = next
-  }
-}
-
-func booleanLiteralDiscriminantCapture(run func() int) (string, string, int) {
-  var out bytes.Buffer
-  var err bytes.Buffer
-  oldStdout := stdout
-  oldStderr := stderr
-  stdout = &out
-  stderr = &err
-  defer func() {
-    stdout = oldStdout
-    stderr = oldStderr
-  }()
-  code := run()
-  return out.String(), err.String(), code
-}
-
-func booleanLiteralDiscriminantTransform(t *testing.T, project string, output string) string {
-  t.Helper()
-  out, errText, code := booleanLiteralDiscriminantCapture(func() int {
-    return runTransform([]string{
-      "--cwd", project,
-      "--tsconfig", "tsconfig.json",
-      "--file", "src/main.ts",
-      "--output", output,
-    })
-  })
-  if code != 0 {
-    t.Fatalf("boolean literal discriminant transform failed: output=%s code=%d stderr=\n%s", output, code, errText)
-  }
-  return out
-}
-
-func booleanLiteralDiscriminantRunRuntimeCases(t *testing.T, project string, js string) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  runtimeDir := filepath.Join(project, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  if err := os.WriteFile(filepath.Join(runtimeDir, "typia-stub.cjs"), []byte("module.exports = {};\n"), 0o644); err != nil {
-    t.Fatalf("write typia stub: %v", err)
-  }
-  runtimeJS := strings.ReplaceAll(js, `require("typia")`, `require("./typia-stub.cjs")`)
-  if strings.Contains(js, `require("typia")`) && !strings.Contains(runtimeJS, `require("./typia-stub.cjs")`) {
-    t.Fatal("runtime module did not rewrite the typia import to the empty stub")
-  }
-  for _, needle := range []string{`require("typia")`, `require('typia')`, `from "typia"`, `from 'typia'`} {
-    if strings.Contains(runtimeJS, needle) {
-      t.Fatalf("runtime module still contains root typia import %q", needle)
-    }
-  }
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(booleanLiteralDiscriminantRuntimeRunner), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = project
-  output, err := cmd.CombinedOutput()
-  if err != nil {
-    t.Fatalf("boolean literal discriminant runtime cases failed: %v\n%s", err, output)
-  }
-}
-
-const booleanLiteralDiscriminantTSConfig = `{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "moduleResolution": "bundler",
-    "ignoreDeprecations": "6.0",
-    "types": ["*"],
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true
-  },
-  "include": ["src"]
-}
-`
-
-const booleanLiteralDiscriminantSource = `import typia from "typia";
-
-interface IFailure {
-  ok: false;
-  error: {
-    code: string;
-  };
-}
-
-interface ISuccess {
-  ok: true;
-  code: string;
-  data: {
-    id: string;
-  };
-}
-
-type Output = IFailure | ISuccess;
-
-interface IController {
-  getMe(): Promise<Output>;
-  getMeInline(): Promise<
-    | { ok: false; error: { code: string } }
-    | { ok: true; code: string; data: { id: string } }
-  >;
-}
-
-export const reflectFalse = typia.reflect.schema<false>();
-export const reflectOutput = typia.reflect.schema<Output>();
-export const jsonOutput = typia.json.schema<Output>();
-export const jsonApplication = typia.json.application<IController>();
-`
-
-const booleanLiteralDiscriminantRuntimeRunner = `const {
-  reflectFalse,
-  reflectOutput,
-  jsonOutput,
-  jsonApplication,
-} = require("./main.cjs");
-
-const assertValues = (name, actual, expected) => {
-  const normalized = [...actual].sort((x, y) => Number(x) - Number(y));
-  if (JSON.stringify(normalized) !== JSON.stringify(expected)) {
-    throw new Error(name + ": expected " + JSON.stringify(expected) + " but got " + JSON.stringify(normalized));
-  }
-};
-
-const assertStrings = (name, actual, expected) => {
-  const normalized = [...actual].sort();
-  if (JSON.stringify(normalized) !== JSON.stringify(expected)) {
-    throw new Error(name + ": expected " + JSON.stringify(expected) + " but got " + JSON.stringify(normalized));
-  }
-};
-
-const reflectProperty = (object, key) =>
-  object.properties.find(
-    (property) =>
-      property.key.constants[0]?.type === "string" &&
-      property.key.constants[0]?.values[0]?.value === key,
-  );
-
-const reflectOkConstant = (object) =>
-  reflectProperty(object, "ok")?.value.constants
-    .find((constant) => constant.type === "boolean")
-    ?.values.map((value) => value.value)
-    .filter((value) => typeof value === "boolean");
-
-const collectReflectOkConstants = (unit) =>
-  unit.components.objects
-    .filter((object) => reflectProperty(object, "ok") !== undefined)
-    .flatMap((object) => reflectOkConstant(object) ?? []);
-
-const assertReflectBranch = (unit, sibling, expected) => {
-  const branch = unit.components.objects.find(
-    (object) =>
-      reflectProperty(object, "ok") !== undefined &&
-      reflectProperty(object, sibling) !== undefined,
-  );
-  if (branch === undefined) {
-    throw new Error("reflect branch with property " + sibling + " was not emitted");
-  }
-  assertValues("reflect branch " + sibling + " ok constant", reflectOkConstant(branch) ?? [], [expected]);
-};
-
-const schemaName = (ref) => ref.split("/").at(-1);
-
-const collectJsonRefs = (schema) => {
-  const visit = (current) => {
-    if (typeof current?.$ref === "string") return [current.$ref];
-    if (Array.isArray(current?.oneOf)) return current.oneOf.flatMap(visit);
-    if (current?.type === "object") {
-      return Object.values(current.properties ?? {}).flatMap(visit);
-    }
-    return [];
-  };
-  return visit(schema);
-};
-
-const collectJsonOkConstants = (schema, components) => {
-  const visited = new Set();
-  const visit = (current) => {
-    if (typeof current?.$ref === "string") {
-      if (visited.has(current.$ref)) return [];
-      visited.add(current.$ref);
-      const target = components.schemas?.[schemaName(current.$ref)];
-      return target === undefined ? [] : visit(target);
-    }
-    if (Array.isArray(current?.oneOf)) return current.oneOf.flatMap(visit);
-    if (current?.type === "object") {
-      const ok = current.properties?.ok;
-      return typeof ok?.const === "boolean" ? [ok.const] : [];
-    }
-    return [];
-  };
-  return visit(schema);
-};
-
-const collectJsonObjects = (schema, components) => {
-  const visited = new Set();
-  const visit = (current) => {
-    if (typeof current?.$ref === "string") {
-      if (visited.has(current.$ref)) return [];
-      visited.add(current.$ref);
-      const target = components.schemas?.[schemaName(current.$ref)];
-      return target === undefined ? [] : visit(target);
-    }
-    if (Array.isArray(current?.oneOf)) return current.oneOf.flatMap(visit);
-    if (current?.type === "object") return [current];
-    return [];
-  };
-  return visit(schema);
-};
-
-const assertJsonBranch = (name, schema, components, sibling, expected) => {
-  const branch = collectJsonObjects(schema, components).find(
-    (object) =>
-      object.properties?.ok !== undefined &&
-      object.properties?.[sibling] !== undefined,
-  );
-  if (branch === undefined) {
-    throw new Error(name + " branch with property " + sibling + " was not emitted");
-  }
-  const actual = branch.properties.ok?.const;
-  if (actual !== expected) {
-    throw new Error(name + " branch " + sibling + " expected ok " + expected + " but got " + actual);
-  }
-};
-
-if (reflectFalse.schema.constants[0]?.type !== "boolean") {
-  throw new Error("bare false literal did not emit a boolean constant");
-}
-if (reflectFalse.schema.constants[0]?.values[0]?.value !== false) {
-  throw new Error("bare false literal was not preserved");
-}
-
-assertValues("reflect union ok constants", collectReflectOkConstants(reflectOutput), [false, true]);
-assertReflectBranch(reflectOutput, "error", false);
-assertReflectBranch(reflectOutput, "data", true);
-
-if (jsonOutput.components.schemas?.IFailure === undefined) {
-  throw new Error("json schema did not emit IFailure component");
-}
-if (jsonOutput.components.schemas?.ISuccess === undefined) {
-  throw new Error("json schema did not emit ISuccess component");
-}
-assertStrings("json schema branch refs", collectJsonRefs(jsonOutput.schema), [
-  "#/components/schemas/IFailure",
-  "#/components/schemas/ISuccess",
-]);
-assertValues("json schema ok constants", collectJsonOkConstants(jsonOutput.schema, jsonOutput.components), [false, true]);
-assertJsonBranch("json schema", jsonOutput.schema, jsonOutput.components, "error", false);
-assertJsonBranch("json schema", jsonOutput.schema, jsonOutput.components, "data", true);
-
-const getMe = jsonApplication.functions.find((func) => func.name === "getMe");
-if (getMe?.output === undefined) {
-  throw new Error("json application did not emit getMe output");
-}
-if (jsonApplication.components.schemas?.IFailure === undefined) {
-  throw new Error("json application did not emit IFailure component");
-}
-if (jsonApplication.components.schemas?.ISuccess === undefined) {
-  throw new Error("json application did not emit ISuccess component");
-}
-if (jsonApplication.components.schemas?.Output === undefined) {
-  throw new Error("json application did not emit Output component");
-}
-assertStrings("json application output ref", collectJsonRefs(getMe.output.schema), [
-  "#/components/schemas/Output",
-]);
-assertStrings("json application Output branch refs", collectJsonRefs(jsonApplication.components.schemas.Output), [
-  "#/components/schemas/IFailure",
-  "#/components/schemas/ISuccess",
-]);
-assertValues(
-  "json application output ok constants",
-  collectJsonOkConstants(getMe.output.schema, jsonApplication.components),
-  [false, true],
-);
-assertJsonBranch("json application output", getMe.output.schema, jsonApplication.components, "error", false);
-assertJsonBranch("json application output", getMe.output.schema, jsonApplication.components, "data", true);
-
-const getMeInline = jsonApplication.functions.find((func) => func.name === "getMeInline");
-if (getMeInline?.output === undefined) {
-  throw new Error("json application did not emit getMeInline output");
-}
-assertValues(
-  "json application inline output ok constants",
-  collectJsonOkConstants(getMeInline.output.schema, jsonApplication.components),
-  [false, true],
-);
-assertJsonBranch("json application inline output", getMeInline.output.schema, jsonApplication.components, "error", false);
-assertJsonBranch("json application inline output", getMeInline.output.schema, jsonApplication.components, "data", true);
-`