Bump softprops/action-gh-release from 2 to 3

Bumps [softprops/action-gh-release](https://github.com/softprops/action-gh-release) from 2 to 3.
- [Release notes](https://github.com/softprops/action-gh-release/releases)
- [Changelog](https://github.com/softprops/action-gh-release/blob/master/CHANGELOG.md)
- [Commits](https://github.com/softprops/action-gh-release/compare/v2...v3)

---
updated-dependencies:
- dependency-name: softprops/action-gh-release
  dependency-version: '3'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/build.yml

@@ -51,7 +51,7 @@ jobs:
       if: startsWith(github.ref, 'refs/tags/')
       run: zip Linux.flatc.binary.${{ matrix.cxx }}.zip flatc
     - name: Release zip file
-      uses: softprops/action-gh-release@v2
+      uses: softprops/action-gh-release@v3
       if: startsWith(github.ref, 'refs/tags/')
       with:
         files: Linux.flatc.binary.${{ matrix.cxx }}.zip
@@ -179,7 +179,7 @@ jobs:
       if: startsWith(github.ref, 'refs/tags/')
       run: move Release/flatc.exe . && Compress-Archive flatc.exe Windows.flatc.binary.zip
     - name: Release binary
-      uses: softprops/action-gh-release@v2
+      uses: softprops/action-gh-release@v3
       if: startsWith(github.ref, 'refs/tags/')
       with:
         files: Windows.flatc.binary.zip
@@ -255,7 +255,7 @@ jobs:
       if: startsWith(github.ref, 'refs/tags/')
       run: mv Release/flatc . && zip MacIntel.flatc.binary.zip flatc
     - name: Release binary
-      uses: softprops/action-gh-release@v2
+      uses: softprops/action-gh-release@v3
       if: startsWith(github.ref, 'refs/tags/')
       with:
         files: MacIntel.flatc.binary.zip
@@ -298,7 +298,7 @@ jobs:
       if: startsWith(github.ref, 'refs/tags/')
       run: mv Release/flatc . && zip Mac.flatc.binary.zip flatc
     - name: Release binary
-      uses: softprops/action-gh-release@v2
+      uses: softprops/action-gh-release@v3
       if: startsWith(github.ref, 'refs/tags/')
       with:
         files: Mac.flatc.binary.zip
@@ -495,7 +495,7 @@ jobs:
     name: Test Swift Linux
     strategy:
       matrix:
-        swift: ["5.10", "6.1", "6.2"]
+        swift: ["6.0", "6.1", "6.2"]
     runs-on: ubuntu-24.04
     steps:
     - uses: actions/checkout@v6
@@ -534,7 +534,7 @@ jobs:
          run: |
            swift sdk list
            swift build --build-tests --swift-sdk swift-6.2.1-RELEASE_wasm
-           wasmtime --dir . .build/wasm32-unknown-wasip1/debug/FlatBuffers.Test.Swift.WasmPackageTests.xctest
+           wasmtime --dir . .build/wasm32-unknown-wasip1/debug/FlatBuffers.Test.Swift.WasmPackageTests.xctest --testing-library swift-testing
 
   build-ts:
     name: Build TS

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.10
+// swift-tools-version:6.0
 /*
  * Copyright 2020 Google Inc. All rights reserved.
  *
@@ -36,14 +36,17 @@ let package = Package(
     .target(
       name: "FlatBuffers",
       dependencies: ["Common"],
-      path: "swift/Sources/FlatBuffers"),
+      path: "swift/Sources/FlatBuffers",
+      swiftSettings: .settings),
     .target(
       name: "FlexBuffers",
       dependencies: ["Common"],
-      path: "swift/Sources/FlexBuffers"),
+      path: "swift/Sources/FlexBuffers",
+      swiftSettings: .settings),
     .target(
       name: "Common",
-      path: "swift/Sources/Common"),
+      path: "swift/Sources/Common",
+      swiftSettings: .settings),
     .testTarget(
       name: "FlatbuffersTests",
       dependencies: .dependencies,
@@ -52,7 +55,14 @@ let package = Package(
       name: "FlexbuffersTests",
       dependencies: ["FlexBuffers"],
       path: "tests/swift/Tests/Flexbuffers"),
-  ])
+  ],
+  swiftLanguageModes: [.v6])
+
+extension Array where Element == SwiftSetting {
+  static var settings: [SwiftSetting] {
+    [.enableUpcomingFeature("ExistentialAny")]
+  }
+}
 
 extension Array where Element == Package.Dependency {
   static var dependencies: [Package.Dependency] {
@@ -60,7 +70,12 @@ extension Array where Element == Package.Dependency {
     []
     #else
     // Test only Dependency
-    [.package(url: "https://github.com/grpc/grpc-swift.git", from: "1.4.1")]
+    [
+      .package(url: "https://github.com/grpc/grpc-swift-2.git", from: "2.0.0"),
+      .package(
+        url: "https://github.com/grpc/grpc-swift-nio-transport.git",
+        from: "2.0.0"),
+    ]
     #endif
   }
 }
@@ -72,7 +87,10 @@ extension Array where Element == PackageDescription.Target.Dependency {
     #else
     // Test only Dependency
     [
-      .product(name: "GRPC", package: "grpc-swift"),
+      .product(name: "GRPCCore", package: "grpc-swift-2"),
+      .product(
+        name: "GRPCNIOTransportHTTP2",
+        package: "grpc-swift-nio-transport"),
       "FlatBuffers",
     ]
     #endif

grpc/examples/greeter_v2.fbs

@@ -0,0 +1,16 @@
+namespace models;
+
+table HelloResponse {
+  message:string;
+}
+
+table HelloRequest {
+  name:string;
+}
+
+rpc_service Greeter {
+  Get(HelloRequest):HelloResponse;
+  Collect(HelloRequest):HelloResponse (streaming: "client");
+  Expand(HelloRequest):HelloResponse (streaming: "server");
+  Update(HelloRequest):HelloResponse (streaming: "bidi");
+}

grpc/examples/swift/Greeter/Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.10
+// swift-tools-version:6.2
 /*
  * Copyright 2020 Google Inc. All rights reserved.
  *
@@ -20,39 +20,43 @@ import PackageDescription
 let package = Package(
   name: "Greeter",
   platforms: [
-    .iOS(.v12),
-    .macOS(.v10_14),
+    .iOS(.v18),
+    .macOS(.v15),
   ],
   dependencies: [
-    .package(path: "../../../../swift"),
-    .package(url: "https://github.com/grpc/grpc-swift.git", from: "1.0.0"),
+    .package(path: "../../../.."),
+    .package(url: "https://github.com/grpc/grpc-swift-2.git", from: "2.0.0"),
+    .package(
+      url: "https://github.com/grpc/grpc-swift-nio-transport.git",
+      from: "2.0.0"),
+    .package(
+      url: "https://github.com/apple/swift-argument-parser.git",
+      from: "1.5.0"),
   ],
   targets: [
     // Targets are the basic building blocks of a package. A target can define a module or a test suite.
     // Targets can depend on other targets in this package, and on products in packages which this package depends on.
     .target(
-      name: "Model",
+      name: "Models",
       dependencies: [
-        "GRPC",
-        "FlatBuffers",
-      ],
-      path: "Sources/Model"),
+        .product(name: "FlatBuffers", package: "flatbuffers"),
+        .product(name: "GRPCCore", package: "grpc-swift-2"),
+        .product(
+          name: "GRPCNIOTransportHTTP2",
+          package: "grpc-swift-nio-transport"),
+      ]),
 
     // Client for the Greeter example
-    .target(
-      name: "Client",
+    .executableTarget(
+      name: "Commands",
       dependencies: [
-        "GRPC",
-        "Model",
-      ],
-      path: "Sources/client"),
-
-    // Server for the Greeter example
-    .target(
-      name: "Server",
-      dependencies: [
-        "GRPC",
-        "Model",
-      ],
-      path: "Sources/server"),
+        .product(name: "GRPCCore", package: "grpc-swift-2"),
+        .product(
+          name: "GRPCNIOTransportHTTP2",
+          package: "grpc-swift-nio-transport"),
+        .product(
+          name: "ArgumentParser",
+          package: "swift-argument-parser"),
+        "Models",
+      ]),
   ])

grpc/examples/swift/Greeter/Sources/Commands/Commands.swift

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import ArgumentParser
+
+let port = 3000
+
+@main
+struct GreeterCommand: AsyncParsableCommand {
+  static let configuration = CommandConfiguration(
+    commandName: "greeter",
+    abstract: "A multi-tool to run an echo server and execute RPCs against it.",
+    subcommands: [ServerCommand.self, ClientCommand.self])
+}
+

grpc/examples/swift/Greeter/Sources/Commands/Services/GreeterService.swift

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import FlatBuffers
+import GRPCCore
+import Models
+
+struct GreeterService: models_Greeter.SimpleServiceProtocol {
+  func Get(
+    request: GRPCMessage<models_HelloResponse>,
+    context: GRPCCore
+      .ServerContext) async throws -> GRPCMessage<models_HelloResponse>
+  {
+    let model = try request.decode()
+    print("## GreeterService.Get: \(model.message)")
+
+    var builder = FlatBufferBuilder(initialSize: 128)
+    let off = builder.create(string: "Hello \(model.message ?? "Unknown")")
+    let root = models_HelloResponse.createHelloResponse(
+      &builder,
+      messageOffset: off)
+    builder.finish(offset: root)
+    return try GRPCMessage<models_HelloResponse>(builder: &builder)
+  }
+
+  func Collect(
+    request: GRPCCore.RPCAsyncSequence<
+      GRPCMessage<models_HelloResponse>,
+      any Swift.Error
+    >,
+    context: GRPCCore
+      .ServerContext) async throws -> GRPCMessage<models_HelloResponse>
+  {
+    let messages: [String] = try await request
+      .reduce(into: []) { array, message in
+        let model = try message.decode()
+        return array.append(model.message ?? "Unknown")
+      }
+
+    let joined = messages.joined(separator: ", ")
+    print("## GreeterService.Collect: \(joined)")
+
+    var builder = FlatBufferBuilder(initialSize: 128)
+    let off = builder.create(string: "Hello \(joined)")
+    let root = models_HelloResponse.createHelloResponse(
+      &builder,
+      messageOffset: off)
+    builder.finish(offset: root)
+    return try GRPCMessage<models_HelloResponse>(builder: &builder)
+  }
+
+  func Expand(
+    request: GRPCMessage<models_HelloResponse>,
+    response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext) async throws
+  {
+
+    let model = try request.decode()
+    print("## GreeterService.Expand: \(model.message)")
+
+    let message = model.message ?? "Unknown"
+    let stream = AsyncThrowingStream<
+      GRPCMessage<models_HelloResponse>,
+      Error
+    > { continuation in
+      var builder = FlatBufferBuilder(initialSize: 128)
+      for char in message {
+        let off = builder.create(string: "\(char)")
+        let root = models_HelloResponse.createHelloResponse(
+          &builder,
+          messageOffset: off)
+        builder.finish(offset: root)
+
+        do {
+          continuation
+            .yield(try GRPCMessage<models_HelloResponse>(builder: &builder))
+        } catch {
+          continuation.finish(throwing: error)
+        }
+      }
+
+      continuation.finish()
+    }
+    try await response.write(contentsOf: stream)
+  }
+
+  func Update(
+    request: GRPCCore.RPCAsyncSequence<
+      GRPCMessage<models_HelloResponse>,
+      any Swift.Error
+    >,
+    response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext) async throws
+  {
+    for try await message in request {
+      let model = try message.decode()
+      print("## GreeterService.Update: \(model.message)")
+      var builder = FlatBufferBuilder(initialSize: 128)
+      let off = builder.create(string: "Hello \(model.message ?? "Unknown")")
+      let root = models_HelloResponse.createHelloResponse(
+        &builder,
+        messageOffset: off)
+      builder.finish(offset: root)
+      try await response
+        .write(try GRPCMessage<models_HelloResponse>(builder: &builder))
+    }
+  }
+}

grpc/examples/swift/Greeter/Sources/Commands/Subcommands/ClientCommand.swift

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import ArgumentParser
+import FlatBuffers
+import GRPCCore
+import GRPCNIOTransportHTTP2
+import Models
+
+enum ClientRequest: String, ExpressibleByArgument {
+  case get, expand, collect, update
+}
+
+struct ClientCommand: AsyncParsableCommand {
+  static let configuration = CommandConfiguration(
+    commandName: "client")
+
+  @Option(help: "Name to send to the server")
+  var name: String
+
+  @Option(help: "request type")
+  var request: ClientRequest
+
+  func run() async throws {
+    try await withGRPCClient(
+      transport: .http2NIOPosix(
+        target: .dns(host: "localhost", port: port),
+        transportSecurity: .plaintext))
+    {
+      let client = models_Greeter.Client(wrapping: $0)
+
+      switch request {
+      case .get: try await get(client: client)
+      case .expand: try await expand(client: client)
+      case .collect: try await collect(client: client)
+      case .update: try await update(client: client)
+      }
+    }
+  }
+
+  func get(
+    client: models_Greeter
+      .Client<HTTP2ClientTransport.Posix>) async throws
+  {
+    for _ in 0..<3 {
+      var builder = FlatBufferBuilder(initialSize: 64)
+      let off = builder.create(string: name)
+      let root = models_HelloRequest.createHelloRequest(
+        &builder,
+        nameOffset: off)
+      builder.finish(offset: root)
+
+      let response = try await client
+        .Get(GRPCMessage(builder: &builder))
+      let message = try? response.decode().message
+      print("get message: \(message ?? "nil")")
+    }
+  }
+
+  func expand(
+    client: models_Greeter
+      .Client<HTTP2ClientTransport.Posix>) async throws
+  {
+    for _ in 0..<3 {
+      var builder = FlatBufferBuilder(initialSize: 64)
+      let off = builder.create(string: name)
+      let root = models_HelloRequest.createHelloRequest(
+        &builder,
+        nameOffset: off)
+      builder.finish(offset: root)
+      try await client.Expand(GRPCMessage(builder: &builder)) { response in
+        for try await message in response.messages {
+          let message = try? message.decode().message
+          print("expand message: \(message ?? "nil")")
+        }
+      }
+    }
+  }
+
+  func collect(
+    client: models_Greeter
+      .Client<HTTP2ClientTransport.Posix>) async throws
+  {
+    for _ in 0..<3 {
+      let response = try await client.Collect { writer in
+        for part in name {
+          print("collect sending: \(part)")
+          var builder = FlatBufferBuilder(initialSize: 64)
+          let off = builder.create(string: String(part))
+          let root = models_HelloRequest.createHelloRequest(
+            &builder,
+            nameOffset: off)
+          builder.finish(offset: root)
+          try await writer.write(GRPCMessage(builder: &builder))
+        }
+      }
+
+      let message = try response.decode().message
+      print("collect message: \(message ?? "nil")")
+    }
+  }
+
+  func update(
+    client: models_Greeter
+      .Client<HTTP2ClientTransport.Posix>) async throws
+  {
+    for _ in 0..<3 {
+      try await client.Update { writer in
+        for part in name {
+          print("update sending: \(part)")
+          var builder = FlatBufferBuilder(initialSize: 64)
+          let off = builder.create(string: String(part))
+          let root = models_HelloRequest.createHelloRequest(
+            &builder,
+            nameOffset: off)
+          builder.finish(offset: root)
+          try await writer.write(GRPCMessage(builder: &builder))
+        }
+      } onResponse: { response in
+        for try await message in response.messages {
+          let message = try message.decode().message
+          print("collect message: \(message ?? "nil")")
+        }
+      }
+    }
+  }
+}

grpc/examples/swift/Greeter/Sources/Commands/Subcommands/ServerCommand.swift

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import ArgumentParser
+import GRPCCore
+import GRPCNIOTransportHTTP2
+
+struct ServerCommand: AsyncParsableCommand {
+  static let configuration = CommandConfiguration(
+    commandName: "serve")
+
+  func run() async throws {
+    let server = GRPCServer(
+      transport: .http2NIOPosix(
+        address: .ipv4(host: "127.0.0.1", port: port),
+        transportSecurity: .plaintext),
+      services: [GreeterService()])
+
+    try await withThrowingDiscardingTaskGroup { group in
+      group.addTask { try await server.serve() }
+      if let address = try await server.listeningAddress {
+        print("Echo listening on \(address)")
+      }
+    }
+  }
+}

grpc/examples/swift/Greeter/Sources/Model/greeter.grpc.swift

@@ -1,147 +0,0 @@
-// Generated GRPC code for FlatBuffers swift!
-/// The following code is generated by the Flatbuffers library which might not be in sync with grpc-swift
-/// in case of an issue please open github issue, though it would be maintained
-
-// swiftlint:disable all
-// swiftformat:disable all
-
-#if !os(Windows)
-import Foundation
-import GRPC
-import NIO
-import NIOHTTP1
-import FlatBuffers
-
-public protocol GRPCFlatBufPayload: GRPCPayload, FlatBufferGRPCMessage {}
-public extension GRPCFlatBufPayload {
-  init(serializedByteBuffer: inout NIO.ByteBuffer) throws {
-    self.init(byteBuffer: FlatBuffers.ByteBuffer(contiguousBytes: serializedByteBuffer.readableBytesView, count: serializedByteBuffer.readableBytes))
-  }
-  func serialize(into buffer: inout NIO.ByteBuffer) throws {
-    withUnsafeReadableBytes { buffer.writeBytes($0) }
-  }
-}
-extension Message: GRPCFlatBufPayload {}
-
-/// Usage: instantiate models_GreeterServiceClient, then call methods of this protocol to make API calls.
-public protocol models_GreeterClientProtocol: GRPCClient {
-
-  var serviceName: String { get }
-
-  var interceptors: models_GreeterClientInterceptorFactoryProtocol? { get }
-
-  func SayHello(
-    _ request: Message<models_HelloRequest>
-    , callOptions: CallOptions?
-  ) -> UnaryCall<Message<models_HelloRequest>, Message<models_HelloReply>>
-
-  func SayManyHellos(
-    _ request: Message<models_HelloRequest>
-    , callOptions: CallOptions?,
-    handler: @escaping (Message<models_HelloReply>) -> Void
-  ) -> ServerStreamingCall<Message<models_HelloRequest>, Message<models_HelloReply>>
-
-}
-
-extension models_GreeterClientProtocol {
-
-  public var serviceName: String { "models.Greeter" }
-
-  public func SayHello(
-    _ request: Message<models_HelloRequest>
-    , callOptions: CallOptions? = nil
-  ) -> UnaryCall<Message<models_HelloRequest>, Message<models_HelloReply>> {
-    return self.makeUnaryCall(
-      path: "/models.Greeter/SayHello",
-      request: request,
-      callOptions: callOptions ?? self.defaultCallOptions,
-      interceptors: self.interceptors?.makeSayHelloInterceptors() ?? []
-    )
-  }
-
-  public func SayManyHellos(
-    _ request: Message<models_HelloRequest>
-    , callOptions: CallOptions? = nil,
-    handler: @escaping (Message<models_HelloReply>) -> Void
-  ) -> ServerStreamingCall<Message<models_HelloRequest>, Message<models_HelloReply>> {
-    return self.makeServerStreamingCall(
-      path: "/models.Greeter/SayManyHellos",
-      request: request,
-      callOptions: callOptions ?? self.defaultCallOptions,
-      interceptors: self.interceptors?.makeSayManyHellosInterceptors() ?? [],
-      handler: handler
-    )
-  }
-}
-
-public protocol models_GreeterClientInterceptorFactoryProtocol {
-  /// - Returns: Interceptors to use when invoking 'SayHello'.
-  func makeSayHelloInterceptors() -> [ClientInterceptor<Message<models_HelloRequest>, Message<models_HelloReply>>]
-
-  /// - Returns: Interceptors to use when invoking 'SayManyHellos'.
-  func makeSayManyHellosInterceptors() -> [ClientInterceptor<Message<models_HelloRequest>, Message<models_HelloReply>>]
-
-}
-
-public final class models_GreeterServiceClient: models_GreeterClientProtocol {
-  public let channel: GRPCChannel
-  public var defaultCallOptions: CallOptions
-  public var interceptors: models_GreeterClientInterceptorFactoryProtocol?
-
-  public init(
-    channel: GRPCChannel,
-    defaultCallOptions: CallOptions = CallOptions(),
-    interceptors: models_GreeterClientInterceptorFactoryProtocol? = nil
-  ) {
-    self.channel = channel
-    self.defaultCallOptions = defaultCallOptions
-    self.interceptors = interceptors
-  }
-}
-
-public protocol models_GreeterProvider: CallHandlerProvider {
-  var interceptors: models_GreeterServerInterceptorFactoryProtocol? { get }
-  func SayHello(request: Message<models_HelloRequest>, context: StatusOnlyCallContext) -> EventLoopFuture<Message<models_HelloReply>>
-  func SayManyHellos(request: Message<models_HelloRequest>, context: StreamingResponseCallContext<Message<models_HelloReply>>) -> EventLoopFuture<GRPCStatus>
-}
-
-public extension models_GreeterProvider {
-
-  var serviceName: Substring { return "models.Greeter" }
-
-  func handle(method name: Substring, context: CallHandlerContext) -> GRPCServerHandlerProtocol? {
-    switch name {
-    case "SayHello":
-    return UnaryServerHandler(
-      context: context,
-      requestDeserializer: GRPCPayloadDeserializer<Message<models_HelloRequest>>(),
-      responseSerializer: GRPCPayloadSerializer<Message<models_HelloReply>>(),
-      interceptors: self.interceptors?.makeSayHelloInterceptors() ?? [],
-      userFunction: self.SayHello(request:context:))
-
-    case "SayManyHellos":
-    return ServerStreamingServerHandler(
-      context: context,
-      requestDeserializer: GRPCPayloadDeserializer<Message<models_HelloRequest>>(),
-      responseSerializer: GRPCPayloadSerializer<Message<models_HelloReply>>(),
-      interceptors: self.interceptors?.makeSayManyHellosInterceptors() ?? [],
-      userFunction: self.SayManyHellos(request:context:))
-
-    default: return nil;
-    }
-  }
-
-}
-
-public protocol models_GreeterServerInterceptorFactoryProtocol {
-  /// - Returns: Interceptors to use when handling 'SayHello'.
-  ///   Defaults to calling `self.makeInterceptors()`.
-  func makeSayHelloInterceptors() -> [ServerInterceptor<Message<models_HelloRequest>, Message<models_HelloReply>>]
-
-  /// - Returns: Interceptors to use when handling 'SayManyHellos'.
-  ///   Defaults to calling `self.makeInterceptors()`.
-  func makeSayManyHellosInterceptors() -> [ServerInterceptor<Message<models_HelloRequest>, Message<models_HelloReply>>]
-
-}
-#endif
-

grpc/examples/swift/Greeter/Sources/Models/greeter_v2.grpc.swift

@@ -0,0 +1,572 @@
+// Generated GRPC code for FlatBuffers swift!
+/// The following code is generated by the Flatbuffers library which might not be in sync with grpc-swift
+/// in case of an issue please open github issue, though it would be maintained
+
+// swiftlint:disable all
+// swiftformat:disable all
+
+#if !os(Windows) && compiler(>=6.0)
+import FlatBuffers
+import Foundation
+import GRPCCore
+import GRPCNIOTransportCore
+
+
+/// Usage: instantiate models.GreeterServiceClient, then call methods of this protocol to make API calls.
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension FlatBuffersMessageSerializer: MessageSerializer {
+  public func serialize<Bytes>(_ message: Message) throws -> Bytes where Bytes : GRPCCore.GRPCContiguousBytes {
+    do {
+      return try self.serialize(message: message) { GRPCNIOTransportBytes($0) } as! Bytes
+    } catch let error {
+      throw RPCError(
+        code: .invalidArgument,
+        message: "Can't serialize message",
+        cause: error
+      )
+    }
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension FlatBuffersMessageDeserializer: MessageDeserializer {
+  public func deserialize<Bytes>(_ serializedMessageBytes: Bytes) throws -> Message where Bytes : GRPCCore.GRPCContiguousBytes {
+    do {
+      return try serializedMessageBytes.withUnsafeBytes {
+        try self.deserialize(pointer: $0)
+      }
+    } catch let error {
+      throw RPCError(
+        code: .invalidArgument,
+        message: "Can't Decode message of type \(Message.self)",
+        cause: error
+      )
+    }
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+public enum models_Greeter: Sendable {
+  public static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter")
+  public enum Method: Sendable {
+    public enum Get: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = models_HelloResponse
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
+        method: "Get"
+      )
+    }
+    public enum Collect: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = models_HelloResponse
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
+        method: "Collect"
+      )
+    }
+    public enum Expand: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = models_HelloResponse
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
+        method: "Expand"
+      )
+    }
+    public enum Update: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = models_HelloResponse
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
+        method: "Update"
+      )
+    }
+    public static let descriptors: [GRPCCore.MethodDescriptor] = [
+      Get.descriptor,
+      Collect.descriptor,
+      Expand.descriptor,
+      Update.descriptor,
+    ]
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension GRPCCore.ServiceDescriptor {
+  public static let models_Greeter = GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter")
+}
+
+// MARK: models.Greeter Server
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter {
+  public protocol StreamingServiceProtocol: GRPCCore.RegistrableRPCService {
+    func Get(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Collect(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Expand(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Update(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+  }
+  
+  public protocol ServiceProtocol: models_Greeter.StreamingServiceProtocol {
+    func Get(
+      request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Collect(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Expand(
+      request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+    func Update(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
+    
+  }
+  
+  public protocol SimpleServiceProtocol: models_Greeter.ServiceProtocol {
+    func Get(
+      request: GRPCMessage<models_HelloResponse>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCMessage<models_HelloResponse>
+    
+    func Collect(
+      request: GRPCCore.RPCAsyncSequence<GRPCMessage<models_HelloResponse>, any Swift.Error>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCMessage<models_HelloResponse>
+    
+    func Expand(
+      request: GRPCMessage<models_HelloResponse>,
+      response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws
+    
+    func Update(
+      request: GRPCCore.RPCAsyncSequence<GRPCMessage<models_HelloResponse>, any Swift.Error>,
+      response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
+      context: GRPCCore.ServerContext
+    ) async throws
+    
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter.StreamingServiceProtocol {
+  public func registerMethods<Transport>(with router: inout GRPCCore.RPCRouter<Transport>) where Transport: GRPCCore.ServerTransport {
+    router.registerHandler(
+      forMethod: models_Greeter.Method.Get.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      handler: { request, context in
+        try await self.Get(
+          request: request,
+          context: context
+        )
+      }
+    )
+    router.registerHandler(
+      forMethod: models_Greeter.Method.Collect.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      handler: { request, context in
+        try await self.Collect(
+          request: request,
+          context: context
+        )
+      }
+    )
+    router.registerHandler(
+      forMethod: models_Greeter.Method.Expand.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      handler: { request, context in
+        try await self.Expand(
+          request: request,
+          context: context
+        )
+      }
+    )
+    router.registerHandler(
+      forMethod: models_Greeter.Method.Update.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      handler: { request, context in
+        try await self.Update(
+          request: request,
+          context: context
+        )
+      }
+    )
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter.ServiceProtocol {
+  public func Get(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
+    let response = try await self.Get(
+      request: GRPCCore.ServerRequest(stream: request),
+      context: context
+    )
+    return GRPCCore.StreamingServerResponse(single: response)
+  }
+  public func Collect(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
+    let response = try await self.Collect(
+      request: request,
+      context: context
+    )
+    return GRPCCore.StreamingServerResponse(single: response)
+  }
+  public func Expand(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
+    let response = try await self.Expand(
+      request: GRPCCore.ServerRequest(stream: request),
+      context: context
+    )
+    return response
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter.SimpleServiceProtocol {
+  public func Get(
+    request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>> {
+    return GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>(
+      message: try await self.Get(
+        request: request.message,
+        context: context
+      ),
+      metadata: [:]
+    )
+  }
+  public func Collect(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>> {
+    return GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>(
+      message: try await self.Collect(
+        request: request.messages,
+        context: context
+      ),
+      metadata: [:]
+    )
+  }
+  public func Expand(
+    request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
+    return GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>(
+      metadata: [:],
+      producer: { writer in
+        try await self.Expand(
+          request: request.message,
+          response: writer,
+          context: context
+        )
+        return [:]
+      }
+    )
+  }
+  public func Update(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
+    return GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>(
+      metadata: [:],
+      producer: { writer in
+        try await self.Update(
+          request: request.messages,
+          response: writer,
+          context: context
+        )
+        return [:]
+      }
+    )
+  }
+}
+
+
+// MARK: models.Greeter Client
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter {
+  public protocol ClientProtocol: Sendable {
+    func Get<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+    func Collect<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+    func Expand<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+    func Update<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter {
+  public struct Client<Transport>: ClientProtocol where Transport: GRPCCore.ClientTransport {
+    private let client: GRPCCore.GRPCClient<Transport>
+    
+    public init(wrapping client: GRPCCore.GRPCClient<Transport>) {
+      self.client = client
+    }
+    
+    public func Get<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.unary(
+        request: request,
+        descriptor: models_Greeter.Method.Get.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+    public func Collect<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.clientStreaming(
+        request: request,
+        descriptor: models_Greeter.Method.Collect.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+    public func Expand<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.serverStreaming(
+        request: request,
+        descriptor: models_Greeter.Method.Expand.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+    public func Update<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.bidirectionalStreaming(
+        request: request,
+        descriptor: models_Greeter.Method.Update.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter.ClientProtocol {
+  public func Get<Result>(
+    request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
+  ) async throws -> Result where Result: Sendable {
+    try await self.Get(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Collect<Result>(
+    request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
+  ) async throws -> Result where Result: Sendable {
+    try await self.Collect(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Expand<Result>(
+    request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    try await self.Expand(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Update<Result>(
+    request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    try await self.Update(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension models_Greeter.ClientProtocol {
+  public func Get<Result>(
+    _ message: GRPCMessage<models_HelloResponse>,
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { try $0.message }
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>(
+      message: message,
+      metadata: metadata
+    )
+    return try await self.Get(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Collect<Result>(
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    requestProducer producer: @Sendable @escaping (GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>) async throws -> Void,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { try $0.message }
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>(
+      metadata: metadata,
+      producer: producer
+    )
+    return try await self.Collect(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Expand<Result>(
+    _ message: GRPCMessage<models_HelloResponse>,
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>(
+      message: message,
+      metadata: metadata
+    )
+    return try await self.Expand(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Update<Result>(
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    requestProducer producer: @Sendable @escaping (GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>) async throws -> Void,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>(
+      metadata: metadata,
+      producer: producer
+    )
+    return try await self.Update(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+}
+
+#endif
+

grpc/examples/swift/Greeter/Sources/Models/greeter_v2_generated.swift

@@ -8,7 +8,7 @@ import Common
 
 import FlatBuffers
 
-public struct models_HelloReply: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {
+public struct models_HelloResponse: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -23,16 +23,16 @@ public struct models_HelloReply: FlatBufferTable, FlatbuffersVectorInitializable
 
   public var message: String? { let o = _accessor.offset(VT.message); return o == 0 ? nil : _accessor.string(at: o) }
   public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.message) }
-  public static func startHelloReply(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+  public static func startHelloResponse(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
   public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VT.message) }
-  public static func endHelloReply(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
-  public static func createHelloReply(
+  public static func endHelloResponse(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createHelloResponse(
     _ fbb: inout FlatBufferBuilder,
     messageOffset message: Offset = Offset()
   ) -> Offset {
-    let __start = models_HelloReply.startHelloReply(&fbb)
-    models_HelloReply.add(message: message, &fbb)
-    return models_HelloReply.endHelloReply(&fbb, start: __start)
+    let __start = models_HelloResponse.startHelloResponse(&fbb)
+    models_HelloResponse.add(message: message, &fbb)
+    return models_HelloResponse.endHelloResponse(&fbb, start: __start)
   }
 
   public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
@@ -42,7 +42,7 @@ public struct models_HelloReply: FlatBufferTable, FlatbuffersVectorInitializable
   }
 }
 
-extension models_HelloReply: Encodable {
+extension models_HelloResponse: Encodable {
   enum CodingKeys: String, CodingKey {
     case message = "message"
   }
@@ -53,7 +53,7 @@ extension models_HelloReply: Encodable {
   }
 }
 
-public struct models_HelloRequest: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {
+public struct models_HelloRequest: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

grpc/examples/swift/Greeter/Sources/client/main.swift

@@ -1,108 +0,0 @@
-/*
- * Copyright 2024 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import FlatBuffers
-import GRPC
-import Logging
-import Model
-import NIO
-
-// Quieten the logs.
-LoggingSystem.bootstrap {
-  var handler = StreamLogHandler.standardOutput(label: $0)
-  handler.logLevel = .critical
-  return handler
-}
-
-func greet(name: String, client greeter: models_GreeterServiceClient) {
-  // Form the request with the name, if one was provided.
-  var builder = FlatBufferBuilder()
-  let nameOff = builder.create(string: name)
-  let root = models_HelloRequest.createHelloRequest(
-    &builder,
-    nameOffset: nameOff)
-  builder.finish(offset: root)
-
-  // Make the RPC call to the server.
-  let sayHello =
-    greeter
-      .SayHello(Message<models_HelloRequest>(builder: &builder))
-
-  // wait() on the response to stop the program from exiting before the response is received.
-  do {
-    let response = try sayHello.response.wait()
-    print("Greeter SayHello received: \(response.object.message ?? "Unknown")")
-  } catch {
-    print("Greeter failed: \(error)")
-  }
-
-  let surname = builder.create(string: name)
-  let manyRoot = models_HelloRequest.createHelloRequest(
-    &builder,
-    nameOffset: surname)
-  builder.finish(offset: manyRoot)
-
-  let call = greeter.SayManyHellos(Message(builder: &builder)) { message in
-    print(
-      "Greeter SayManyHellos received: \(message.object.message  ?? "Unknown")")
-  }
-
-  let status = try! call.status.recover { _ in .processingError }.wait()
-  if status.code != .ok {
-    print("RPC failed: \(status)")
-  }
-}
-
-func main(args: [String]) {
-  // arg0 (dropped) is the program name. We expect arg1 to be the port, and arg2 (optional) to be
-  // the name sent in the request.
-  let arg1 = args.dropFirst(1).first
-  let arg2 = args.dropFirst(2).first
-
-  switch (arg1.flatMap(Int.init), arg2) {
-  case (.none, _):
-    print("Usage: PORT [NAME]")
-    exit(1)
-
-  case (.some(let port), let name):
-    // Setup an `EventLoopGroup` for the connection to run on.
-    //
-    // See: https://github.com/apple/swift-nio#eventloops-and-eventloopgroups
-    let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-
-    // Make sure the group is shutdown when we're done with it.
-    defer {
-      try! group.syncShutdownGracefully()
-    }
-
-    // Configure the channel, we're not using TLS so the connection is `insecure`.
-    let channel = ClientConnection.insecure(group: group)
-      .connect(host: "localhost", port: port)
-
-    // Close the connection when we're done with it.
-    defer {
-      try! channel.close().wait()
-    }
-
-    // Provide the connection to the generated client.
-    let greeter = models_GreeterServiceClient(channel: channel)
-
-    // Do the greeting.
-    greet(name: name ?? "FlatBuffers!", client: greeter)
-  }
-}
-
-main(args: CommandLine.arguments)

grpc/examples/swift/Greeter/Sources/server/main.swift

@@ -1,97 +0,0 @@
-/*
- * Copyright 2024 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import FlatBuffers
-import GRPC
-import Logging
-import Model
-import NIO
-
-class Greeter: models_GreeterProvider {
-
-  var interceptors: models_GreeterServerInterceptorFactoryProtocol?
-
-  let greetings: [String]
-
-  init() {
-    greetings = ["Hi", "Hallo", "Ciao"]
-  }
-
-  func SayHello(
-    request: Message<models_HelloRequest>,
-    context: StatusOnlyCallContext)
-    -> EventLoopFuture<Message<models_HelloReply>>
-  {
-    let recipient = request.object.name ?? "Stranger"
-
-    var builder = FlatBufferBuilder()
-    let off = builder.create(string: "Hello \(recipient)")
-    let root = models_HelloReply.createHelloReply(&builder, messageOffset: off)
-    builder.finish(offset: root)
-    return context.eventLoop
-      .makeSucceededFuture(Message<models_HelloReply>(builder: &builder))
-  }
-
-  func SayManyHellos(
-    request: Message<models_HelloRequest>,
-    context: StreamingResponseCallContext<Message<models_HelloReply>>)
-    -> EventLoopFuture<GRPCStatus>
-  {
-    for name in greetings {
-      var builder = FlatBufferBuilder()
-      let off =
-        builder
-          .create(string: "\(name) \(request.object.name ?? "Unknown")")
-      let root = models_HelloReply.createHelloReply(
-        &builder,
-        messageOffset: off)
-      builder.finish(offset: root)
-      _ = context.sendResponse(Message<models_HelloReply>(builder: &builder))
-    }
-    return context.eventLoop.makeSucceededFuture(.ok)
-  }
-}
-
-// Quieten the logs.
-LoggingSystem.bootstrap {
-  var handler = StreamLogHandler.standardOutput(label: $0)
-  handler.logLevel = .critical
-  return handler
-}
-
-let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-defer {
-  try! group.syncShutdownGracefully()
-}
-
-// Create some configuration for the server:
-let configuration = Server.Configuration(
-  target: .hostAndPort("localhost", 0),
-  eventLoopGroup: group,
-  serviceProviders: [Greeter()])
-
-// Start the server and print its address once it has started.
-let server = Server.start(configuration: configuration)
-server.map {
-  $0.channel.localAddress
-}.whenSuccess { address in
-  print("server started on port \(address!.port!)")
-}
-
-// Wait on the server's `onClose` future to stop the program from exiting.
-_ = try server.flatMap {
-  $0.onClose
-}.wait()

grpc/examples/ts/greeter/src/models.ts

@@ -2,5 +2,5 @@
 
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
 
-export {HelloReply} from './models/hello-reply.js';
-export {HelloRequest} from './models/hello-request.js';
+export { HelloReply } from './models/hello-reply.js';
+export { HelloRequest } from './models/hello-request.js';

grpc/examples/ts/greeter/src/models/hello-reply.ts

@@ -8,7 +8,7 @@ import * as flatbuffers from 'flatbuffers';
 
 export class HelloReply {
   bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
+  bb_pos = 0;
   __init(i:number, bb:flatbuffers.ByteBuffer):HelloReply {
   this.bb_pos = i;
   this.bb = bb;
@@ -31,11 +31,11 @@ message(optionalEncoding?:any):string|Uint8Array|null {
   return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 
-static startHelloReply(builder:flatbuffers.Builder):void {
+static startHelloReply(builder:flatbuffers.Builder) {
   builder.startObject(1);
 }
 
-static addMessage(builder:flatbuffers.Builder, messageOffset:flatbuffers.Offset):void {
+static addMessage(builder:flatbuffers.Builder, messageOffset:flatbuffers.Offset) {
   builder.addFieldOffset(0, messageOffset, 0);
 }
 

grpc/examples/ts/greeter/src/models/hello-request.ts

@@ -8,7 +8,7 @@ import * as flatbuffers from 'flatbuffers';
 
 export class HelloRequest {
   bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
+  bb_pos = 0;
   __init(i:number, bb:flatbuffers.ByteBuffer):HelloRequest {
   this.bb_pos = i;
   this.bb = bb;
@@ -31,11 +31,11 @@ name(optionalEncoding?:any):string|Uint8Array|null {
   return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 
-static startHelloRequest(builder:flatbuffers.Builder):void {
+static startHelloRequest(builder:flatbuffers.Builder) {
   builder.startObject(1);
 }
 
-static addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset):void {
+static addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset) {
   builder.addFieldOffset(0, nameOffset, 0);
 }
 

include/flatbuffers/flexbuffers.h

@@ -1976,7 +1976,7 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   bool VerifyKey(const uint8_t* p) {
     FLEX_CHECK_VERIFIED(p, PackedType(BIT_WIDTH_8, FBT_KEY));
     while (p < buf_ + size_)
-      if (*p++) return true;
+      if (!*p++) return true;
     return false;
   }
 

samples/monster_generated.swift

@@ -161,7 +161,7 @@ public struct MyGame_Sample_Vec3_Mutable: FlatBufferStruct, FlatbuffersVectorIni
   }
 }
 
-public struct MyGame_Sample_Monster: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Sample_Monster: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -400,7 +400,7 @@ public class MyGame_Sample_MonsterT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Sample_Monster.self) }
 
 }
-public struct MyGame_Sample_Weapon: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Sample_Weapon: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

scripts/generate_grpc_examples.py

@@ -20,6 +20,7 @@ from util import flatc, root_path
 grpc_examples_path = Path(root_path, "grpc/examples")
 
 greeter_schema = str(Path(grpc_examples_path, "greeter.fbs"))
+greeter_schema_v2 = str(Path(grpc_examples_path, "greeter_v2.fbs"))
 
 COMMON_ARGS = [
     "--grpc",
@@ -54,8 +55,8 @@ def GenerateGRPCExamples():
           "--swift",
           "--gen-json-emit",
       ],
-      schema=greeter_schema,
-      cwd=Path(grpc_examples_path, "swift/Greeter/Sources/Model"),
+      schema=greeter_schema_v2,
+      cwd=Path(grpc_examples_path, "swift/Greeter/Sources/Models"),
   )
 
   flatc(

src/idl_gen_swift.cpp

@@ -170,9 +170,8 @@ class SwiftGenerator : public BaseGenerator {
     code_ += "// swiftformat:disable all\n";
 
     if (parser_.opts.include_dependence_headers || parser_.opts.generate_all) {
-      code_.SetValue("IMPLEMENTONLY", parser_.opts.swift_implementation_only
-                                          ? "@_implementationOnly "
-                                          : "");
+      code_.SetValue("IMPLEMENTONLY",
+                     parser_.opts.swift_implementation_only ? "internal " : "");
       code_ += "#if canImport(Common)";
       code_ += "{{IMPLEMENTONLY}}import Common";
       code_ += "#endif";
@@ -549,13 +548,14 @@ class SwiftGenerator : public BaseGenerator {
     code_.SetValue("SHORT_STRUCTNAME", namer_.Type(struct_def));
     code_.SetValue("STRUCTNAME", namer_.NamespacedType(struct_def));
     code_.SetValue("OBJECTTYPE", struct_def.fixed ? "Struct" : "Table");
+    code_.SetValue("PROTOCOL", struct_def.fixed ? "FlatBufferStruct"
+                                                : "FlatBufferVerifiableTable");
     code_.SetValue("MUTABLE", struct_def.fixed ? Mutable() : "");
 
     GenOSVersionChecks();
     code_ +=
         "{{ACCESS_TYPE}} struct {{STRUCTNAME}}{{MUTABLE}}: "
-        "FlatBuffer{{OBJECTTYPE}}, FlatbuffersVectorInitializable\\";
-    if (!struct_def.fixed) code_ += ", Verifiable\\";
+        "{{PROTOCOL}}, FlatbuffersVectorInitializable\\";
     if (!struct_def.fixed && parser_.opts.generate_object_based_api)
       code_ += ", ObjectAPIPacker\\";
     code_ += " {\n";

src/idl_gen_ts.cpp

@@ -296,11 +296,11 @@ class TsGenerator : public BaseGenerator {
         auto fully_qualified_type_name =
             it.second.ns->GetFullyQualifiedName(type_name);
         auto is_struct = parser_.structs_.Lookup(fully_qualified_type_name);
-        code += "export {" + type_name;
+        code += "export { " + type_name;
         if (parser_.opts.generate_object_based_api && is_struct) {
           code += ", " + type_name + parser_.opts.object_suffix;
         }
-        code += "} from '";
+        code += " } from '";
         std::string import_extension =
             parser_.opts.ts_no_import_ext ? "" : ".js";
         code += base_name_rel + import_extension + "';\n";
@@ -818,7 +818,7 @@ class TsGenerator : public BaseGenerator {
 
       code += "static finish" + (size_prefixed ? sizePrefixed : "") +
               GetPrefixedName(struct_def) + "Buffer";
-      code += "(builder:flatbuffers.Builder, offset:flatbuffers.Offset):void {\n";
+      code += "(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n";
       code += "  builder.finish(offset";
       if (!parser_.file_identifier_.empty()) {
         code += ", '" + parser_.file_identifier_ + "'";
@@ -1040,7 +1040,7 @@ class TsGenerator : public BaseGenerator {
     std::string import_extension = parser_.opts.ts_no_import_ext ? "" : ".js";
     import.import_statement = "import { " + symbols_expression + " } from '" +
                               rel_file_path + import_extension + "';";
-    import.export_statement = "export {" + symbols_expression + "} from '." +
+    import.export_statement = "export { " + symbols_expression + " } from '." +
                               bare_file_path + import_extension + "';";
     import.dependency = &dependency;
     import.dependent = &dependent;
@@ -1703,7 +1703,7 @@ class TsGenerator : public BaseGenerator {
     }
     code += "  bb: flatbuffers.ByteBuffer|" + null_keyword_ + " = " +
             null_keyword_ + ";\n";
-    code += "  bb_pos: number = 0;\n";
+    code += "  bb_pos = 0;\n";
 
     // Generate the __init method that sets the field in a pre-existing
     // accessor object. This is to allow object reuse.
@@ -2156,7 +2156,7 @@ class TsGenerator : public BaseGenerator {
       GenDocComment(code_ptr);
 
       code += "static start" + GetPrefixedName(struct_def) +
-              "(builder:flatbuffers.Builder):void {\n";
+              "(builder:flatbuffers.Builder) {\n";
 
       code += "  builder.startObject(" +
               NumToString(struct_def.fields.vec.size()) + ");\n";
@@ -2173,7 +2173,7 @@ class TsGenerator : public BaseGenerator {
         GenDocComment(code_ptr);
         code += "static " + namer_.Method("add", field);
         code += "(builder:flatbuffers.Builder, " + argname + ":" +
-                GetArgType(imports, struct_def, field, false) + "):void {\n";
+                GetArgType(imports, struct_def, field, false) + ") {\n";
         code += "  builder.addField" + GenWriteMethod(field.value.type) + "(";
         code += NumToString(it - struct_def.fields.vec.begin()) + ", ";
         if (field.value.type.base_type == BASE_TYPE_BOOL) {
@@ -2245,7 +2245,7 @@ class TsGenerator : public BaseGenerator {
 
           code += "static ";
           code += namer_.Method("start", field, "Vector");
-          code += "(builder:flatbuffers.Builder, numElems:number):void {\n";
+          code += "(builder:flatbuffers.Builder, numElems:number) {\n";
           code += "  builder.startVector(" + NumToString(elem_size);
           code += ", numElems, " + NumToString(alignment) + ");\n";
           code += "}\n\n";

swift/Sources/FlatBuffers/ByteBuffer.swift

@@ -20,7 +20,7 @@ import Foundation
 /// it allows users to write and read data directly from memory thus the use of its
 /// functions should be used
 @frozen
-public struct ByteBuffer {
+public struct ByteBuffer: @unchecked Sendable {
 
   /// Storage is a container that would hold the memory pointer to solve the issue of
   /// deallocating the memory that was held by (memory: UnsafeMutableRawPointer)
@@ -30,7 +30,7 @@ public struct ByteBuffer {
     enum Blob {
       #if !os(WASI)
       case data(Data)
-      case bytes(ContiguousBytes)
+      case bytes(any ContiguousBytes)
       #endif
 
       case byteBuffer(_InternalByteBuffer)

swift/Sources/FlatBuffers/Enum.swift

@@ -23,7 +23,7 @@ import Common
 /// Enum is a protocol that all flatbuffers enums should conform to
 /// Since it allows us to get the actual `ByteSize` and `Value` from
 /// a swift enum.
-public protocol Enum {
+public protocol Enum: Sendable {
   /// associatedtype that the type of the enum should conform to
   associatedtype T: Scalar & Verifiable
   /// Size of the current associatedtype in the enum

swift/Sources/FlatBuffers/FlatBufferBuilder.swift

@@ -45,7 +45,7 @@ public struct FlatBufferBuilder {
   /// Dictonary that stores a map of all the strings that were written to the buffer
   private var stringOffsetMap: [String: Offset] = [:]
   /// A check to see if finish(::) was ever called to retreive data object
-  private var finished = false
+  private(set) var finished = false
   /// A check to see if the buffer should serialize Default values
   private var serializeDefaults: Bool
 
@@ -488,7 +488,7 @@ public struct FlatBufferBuilder {
   ///
   /// - Parameter bytes: bytes to be written into the buffer
   /// - Returns: ``Offset`` of the vector
-  mutating public func createVector(bytes: ContiguousBytes) -> Offset {
+  mutating public func createVector(bytes: any ContiguousBytes) -> Offset {
     bytes.withUnsafeBytes {
       startVector($0.count, elementSize: MemoryLayout<UInt8>.size)
       _bb.push(bytes: $0)

swift/Sources/FlatBuffers/FlatBufferObject.swift

@@ -20,6 +20,8 @@ import Foundation
 /// since now we will be serializing native structs into the buffer.
 public protocol NativeStruct {}
 
+public protocol FlatBufferVerifiableNativeStruct: NativeStruct, Verifiable {}
+
 /// FlatbuffersInitializable is a protocol that allows any object to be
 /// Initialized from a ByteBuffer
 public protocol FlatbuffersInitializable {
@@ -35,6 +37,8 @@ public protocol FlatBufferTable: FlatbuffersInitializable,
   var __buffer: ByteBuffer! { get }
 }
 
+public protocol FlatBufferVerifiableTable: FlatBufferTable, Verifiable {}
+
 /// FlatbufferStruct structures all the Flatbuffers structs
 public protocol FlatBufferStruct: FlatbuffersInitializable,
   FlatbuffersVectorInitializable

swift/Sources/FlatBuffers/Message.swift

@@ -16,50 +16,52 @@
 
 import Foundation
 
-/// FlatBufferGRPCMessage protocol that should allow us to invoke
-/// initializers directly from the GRPC generated code
-public protocol FlatBufferGRPCMessage {
-  /// Size of readable bytes in the buffer
-  var size: Int { get }
-
-  init(byteBuffer: ByteBuffer)
-
-  @discardableResult
-  @inline(__always)
-  func withUnsafeReadableBytes<T>(
-    _ body: (UnsafeRawBufferPointer) throws
-      -> T) rethrows -> T
+enum FlatbuffersGRPCError: Error {
+  case finishedNotCalledOnBuilder
 }
 
-/// Message is a wrapper around Buffers to to able to send Flatbuffers `Buffers` through the
-/// GRPC library
-public struct Message<T: FlatBufferTable>: FlatBufferGRPCMessage {
-  internal var buffer: ByteBuffer
+public protocol GRPCVerifiableMessage<Message> {
+  associatedtype Message
 
-  /// Returns the an object of type T that would be  read from the buffer
-  public var object: T {
-    T.init(
-      buffer,
-      o: Int32(buffer.read(def: UOffset.self, position: buffer.reader)) &+
-        Int32(buffer.reader))
-  }
+  init(pointer: UnsafeRawBufferPointer)
+  init(byteBuffer: ByteBuffer)
+
+  func decode() throws -> Message
+  func withUnsafeReadableBytes<Data>(
+    _ body: (UnsafeRawBufferPointer) throws
+      -> Data) rethrows -> Data
+}
+
+public struct GRPCMessage<
+  Table: FlatBufferVerifiableTable
+>: Sendable, GRPCVerifiableMessage {
+  public typealias Message = Table
+
+  private let buffer: ByteBuffer
 
   public var size: Int { Int(buffer.size) }
 
-  /// Initializes the message with the type Flatbuffer.Bytebuffer that is transmitted over
-  /// GRPC
-  /// - Parameter byteBuffer: Flatbuffer ByteBuffer object
+  public init(pointer: UnsafeRawBufferPointer) {
+    buffer = ByteBuffer(
+      copyingMemoryBound: pointer.baseAddress!,
+      capacity: pointer.count)
+  }
+
+  public init(builder: inout FlatBufferBuilder) throws {
+    guard builder.finished else {
+      throw FlatbuffersGRPCError.finishedNotCalledOnBuilder
+    }
+
+    buffer = builder.sizedBuffer
+  }
+
   public init(byteBuffer: ByteBuffer) {
     buffer = byteBuffer
   }
 
-  /// Initializes the message by copying the buffer to the message to be sent.
-  /// from the builder
-  /// - Parameter builder: FlatbufferBuilder that has the bytes created in
-  /// - Note: Use  `builder.finish(offset)` before passing the builder without prefixing anything to it
-  public init(builder: inout FlatBufferBuilder) {
-    buffer = builder.sizedBuffer
-    builder.clear()
+  public func decode() throws -> Table {
+    var buf = buffer
+    return try getCheckedRoot(byteBuffer: &buf)
   }
 
   @discardableResult
@@ -73,3 +75,30 @@ public struct Message<T: FlatBufferTable>: FlatBufferGRPCMessage {
     }
   }
 }
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+public struct FlatBuffersMessageSerializer<
+  Message: GRPCVerifiableMessage
+>: Sendable {
+  public init() {}
+
+  public func serialize<Data>(
+    message: Message,
+    _ completion: (UnsafeRawBufferPointer) throws -> Data) throws -> Data
+  {
+    return try message.withUnsafeReadableBytes {
+      try completion($0)
+    }
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+public struct FlatBuffersMessageDeserializer<
+  Message: GRPCVerifiableMessage
+>: Sendable {
+  public init() {}
+
+  public func deserialize(pointer: UnsafeRawBufferPointer) throws -> Message {
+    Message.init(pointer: pointer)
+  }
+}

swift/Sources/FlatBuffers/TableVerifier.swift

@@ -115,7 +115,7 @@ public struct TableVerifier {
     unionKeyName: String,
     fieldName: String,
     required: Bool,
-    completion: @escaping (inout Verifier, T, Int) throws -> Void) throws
+    completion: (inout Verifier, T, Int) throws -> Void) throws
     where T: UnionEnum
   {
     let keyPos = try dereference(key)

swift/Sources/FlatBuffers/Vectors/FlatbufferVector.swift

@@ -68,7 +68,7 @@ public struct FlatbufferVector<
 }
 
 extension FlatbufferVector: Encodable where Element: Encodable {
-  public func encode(to encoder: Encoder) throws {
+  public func encode(to encoder: any Encoder) throws {
     var container = encoder.unkeyedContainer()
     for element in self {
       try container.encode(element)

swift/Sources/FlatBuffers/Vectors/UnionFlatbufferVector.swift

@@ -49,8 +49,8 @@ public struct UnionFlatbufferVector {
 
   public subscript(
     position: Int,
-    Type: FlatbuffersVectorInitializable
-      .Type) -> FlatbuffersVectorInitializable
+    Type: any FlatbuffersVectorInitializable
+      .Type) -> any FlatbuffersVectorInitializable
   {
     guard position < count else {
       fatalError(

swift/Sources/FlatBuffers/_InternalByteBuffer.swift

@@ -146,7 +146,7 @@ struct _InternalByteBuffer {
   #if !os(WASI)
   @inline(__always)
   @usableFromInline
-  mutating func push(bytes: ContiguousBytes) {
+  mutating func push(bytes: any ContiguousBytes) {
     bytes.withUnsafeBytes { ptr in
       ensureSpace(size: ptr.count)
       memcpy(

swift/Sources/FlexBuffers/ByteBuffer.swift

@@ -30,7 +30,7 @@ public struct ByteBuffer {
     enum Blob {
       #if !os(WASI)
       case data(Data)
-      case bytes(ContiguousBytes)
+      case bytes(any ContiguousBytes)
       #endif
 
       case byteBuffer(_InternalByteBuffer)

swift/Sources/FlexBuffers/FlexBufferType.swift

@@ -16,7 +16,7 @@
 
 import Foundation
 
-public enum FlexBufferType: UInt64 {
+public enum FlexBufferType: UInt64, Sendable {
   case null = 0
   /// Variable width signed integer: `Int8, Int16, Int32, Int64`
   case int = 1

swift/Sources/FlexBuffers/Utils/BitWidth.swift

@@ -17,7 +17,7 @@
 import Foundation
 
 @usableFromInline
-enum BitWidth: UInt64, CaseIterable {
+enum BitWidth: UInt64, CaseIterable, Sendable {
   case w8 = 0
   case w16 = 1
   case w32 = 2

swift/Sources/FlexBuffers/Utils/Value.swift

@@ -20,10 +20,10 @@ import Foundation
 import Common
 #endif
 
-public struct Value: Equatable {
+public struct Value: Equatable, Sendable {
 
   @usableFromInline
-  enum Union: Equatable {
+  enum Union: Equatable, Sendable {
     case i(Int64)
     case u(UInt64)
     case f(Double)

swift/Sources/FlexBuffers/Writer/FlexBuffersWriter.swift

@@ -977,6 +977,9 @@ fileprivate struct Stack: RandomAccessCollection {
   mutating func removeAll(keepingCapacity keepCapacity: Bool = false) {
     count = 0
     if !keepCapacity {
+      let ptr = storage.memory
+      defer { ptr.deallocate() }
+
       capacity = Self.initialCapacity
       storage.memory = UnsafeMutableRawPointer.allocate(
         byteCount: capacity,

tests/swift/Tests/Flatbuffers/ByteBufferTests.swift

@@ -14,51 +14,58 @@
  * limitations under the License.
  */
 
-import XCTest
+import Foundation
+import Testing
 
 @testable import FlatBuffers
 
-final class ByteBufferTests: XCTestCase {
+struct ByteBufferTests {
+
+  @Test
   func testCopyingMemory() {
     let count = 100
     let ptr = UnsafeMutableRawPointer.allocate(byteCount: count, alignment: 1)
     let byteBuffer = ByteBuffer(copyingMemoryBound: ptr, capacity: count)
     byteBuffer.withUnsafeBytes { memory in
-      XCTAssertNotEqual(memory.baseAddress, ptr)
+      #expect(memory.baseAddress! != ptr)
     }
   }
 
+  @Test
   func testSamePointer() {
     let count = 100
     let ptr = UnsafeMutableRawPointer.allocate(byteCount: count, alignment: 1)
     let byteBuffer = ByteBuffer(assumingMemoryBound: ptr, capacity: count)
     byteBuffer.withUnsafeBytes { memory in
-      XCTAssertEqual(memory.baseAddress!, ptr)
+      #expect(memory.baseAddress! == ptr)
     }
   }
 
+  @Test
   func testSameDataPtr() {
     let count = 100
     let ptr = Data(repeating: 0, count: count)
     let byteBuffer = ByteBuffer(data: ptr)
     byteBuffer.withUnsafeBytes { memory in
       ptr.withUnsafeBytes { ptr in
-        XCTAssertEqual(memory.baseAddress!, ptr.baseAddress!)
+        #expect(memory.baseAddress! == ptr.baseAddress!)
       }
     }
   }
 
+  @Test
   func testSameArrayPtr() {
     let count = 100
     let ptr: [UInt8] = Array(repeating: 0, count: count)
     let byteBuffer = ByteBuffer(bytes: ptr)
     ptr.withUnsafeBytes { ptr in
       byteBuffer.withUnsafeBytes { memory in
-        XCTAssertEqual(memory.baseAddress, ptr.baseAddress)
+        #expect(memory.baseAddress == ptr.baseAddress)
       }
     }
   }
 
+  @Test
   func testReadingDoubleBuffer() {
     let count = 8
     let array: [Double] = Array(repeating: 8.8, count: count)
@@ -69,15 +76,16 @@ final class ByteBufferTests: XCTestCase {
     }
     let byteBuffer = ByteBuffer(bytes: bytes)
     byteBuffer.withUnsafePointerToSlice(index: 0, count: count) { ptr in
-      XCTAssertEqual(ptr.count, count)
+      #expect(ptr.count == count)
       bytes.withUnsafeBufferPointer {
-        XCTAssertEqual(
-          UnsafeRawPointer($0.baseAddress),
-          UnsafeRawPointer(ptr.baseAddress))
+        #expect(
+          UnsafeRawPointer($0.baseAddress) ==
+            UnsafeRawPointer(ptr.baseAddress))
       }
     }
   }
 
+  @Test
   func testReadingNativeStructs() {
     let array = [
       MyGame_Example_Vec3(
@@ -111,11 +119,11 @@ final class ByteBufferTests: XCTestCase {
     let byteBuffer = ByteBuffer(bytes: bytes)
     byteBuffer
       .withUnsafePointerToSlice(index: 0, count: count) { bufferPointer in
-        XCTAssertEqual(bufferPointer.count, count)
+        #expect(bufferPointer.count == count)
         bytes.withUnsafeBufferPointer { ptr in
-          XCTAssertEqual(
-            UnsafeRawPointer(ptr.baseAddress),
-            UnsafeRawPointer(bufferPointer.baseAddress))
+          #expect(
+            UnsafeRawPointer(ptr.baseAddress) ==
+              UnsafeRawPointer(bufferPointer.baseAddress))
         }
       }
   }
@@ -126,7 +134,3 @@ private struct TestNativeStructs: NativeStruct {
   let y: Double
   let z: Int
 }
-
-extension MyGame_Example_Color: CaseIterable {
-  public static var allCases: [MyGame_Example_Color] = [.red, .blue, .green]
-}

tests/swift/Tests/Flatbuffers/FlatBuffersArraysTests.swift

@@ -16,18 +16,22 @@
 
 #if compiler(>=6.2)
 
-import XCTest
+import Testing
 
 @testable import FlatBuffers
 
-@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
-final class FlatBuffersArraysTests: XCTestCase {
+struct FlatBuffersArraysTests {
 
+  @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
+  @Test
   func testStructSizes() {
-    XCTAssertEqual(MemoryLayout<MyGame_Example_NestedStruct>.size, 32)
-    XCTAssertEqual(MemoryLayout<MyGame_Example_ArrayStruct>.size, 160)
+    #expect(MemoryLayout<MyGame_Example_NestedStruct>.size == 32)
+    #expect(MemoryLayout<MyGame_Example_ArrayStruct>.size == 160)
+    #expect((MemoryLayout<MyGame_Example_LargeArrayStruct>.size == 2496))
   }
 
+  @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
+  @Test
   func testGoldenData() {
     // swiftformat:disable all
     let data: [UInt8] = [
@@ -44,9 +48,11 @@ final class FlatBuffersArraysTests: XCTestCase {
     ]
     // swiftformat:enable all
 
-    XCTAssertEqual(data, createArrayTable())
+    #expect(data == createArrayTable())
   }
 
+  @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
+  @Test
   func testData() throws {
     var buf = ByteBuffer(bytes: createArrayTable())
     let table: MyGame_Example_ArrayTable = try getCheckedRoot(
@@ -57,6 +63,8 @@ final class FlatBuffersArraysTests: XCTestCase {
     verifyNativeStruct(a: table.a)
   }
 
+  @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
+  @Test
   func testObjectAPI() throws {
     var buf = ByteBuffer(bytes: createArrayTable())
     let table: MyGame_Example_ArrayTable = try getCheckedRoot(
@@ -65,105 +73,110 @@ final class FlatBuffersArraysTests: XCTestCase {
     verifyNativeStruct(a: table.unpack().a)
   }
 
+  @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
+  @Test
   func testDefaults() {
-    XCTAssertEqual(
-      MyGame_Example_NestedStruct(),
-      MyGame_Example_NestedStruct(
-        a: [0, 0],
-        b: .a,
-        c: [0, 0],
-        d: [0, 0]))
+    #expect(
+      MyGame_Example_NestedStruct() ==
+        MyGame_Example_NestedStruct(
+          a: [0, 0],
+          b: .a,
+          c: [0, 0],
+          d: [0, 0]))
   }
 
+  @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
   func verifyNativeStruct(a: MyGame_Example_ArrayStruct?) {
     let a = a!
-    XCTAssertEqual(a.a, 12.34)
-    XCTAssertEqual(a.b.count, 15)
+    #expect(a.a == 12.34)
+    #expect(a.b.count == 15)
     var sum: Int32 = 0
     for i in a.b.startIndex..<a.b.endIndex {
       sum += a.b[i]
     }
-    XCTAssertEqual(sum, 120)
-    XCTAssertEqual(a.c, -127)
-    XCTAssertEqual(a.d.count, 2)
+    #expect(sum == 120)
+    #expect(a.c == -127)
+    #expect(a.d.count == 2)
     let nestedStruct1 = a.d[0]
-    XCTAssertEqual(nestedStruct1.a.toArray(), [-1, 2])
-    XCTAssertEqual(nestedStruct1.b, .a)
-    XCTAssertEqual(nestedStruct1.c.toArray(), [.c, .b])
-    XCTAssertEqual(
-      nestedStruct1.d.toArray(),
-      [0x1122334455667788, -0x1122334455667788])
+    #expect(nestedStruct1.a.toArray() == [-1, 2])
+    #expect(nestedStruct1.b == .a)
+    #expect(nestedStruct1.c.toArray() == [.c, .b])
+    #expect(
+      nestedStruct1.d.toArray() ==
+        [0x1122334455667788, -0x1122334455667788])
 
     let nestedStruct2 = a.d[1]
-    XCTAssertEqual(nestedStruct2.a.toArray(), [3, -4])
-    XCTAssertEqual(nestedStruct2.b, .b)
-    XCTAssertEqual(nestedStruct2.c.toArray(), [.b, .a])
-    XCTAssertEqual(
-      nestedStruct2.d.toArray(),
-      [-0x1122334455667788, 0x1122334455667788])
+    #expect(nestedStruct2.a.toArray() == [3, -4])
+    #expect(nestedStruct2.b == .b)
+    #expect(nestedStruct2.c.toArray() == [.b, .a])
+    #expect(
+      nestedStruct2.d.toArray() ==
+        [-0x1122334455667788, 0x1122334455667788])
 
-    XCTAssertEqual(a.e, 1)
-    XCTAssertEqual(a.f.count, 2)
+    #expect(a.e == 1)
+    #expect(a.f.count == 2)
   }
 
+  @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
   func verifyMutations(in table: MyGame_Example_ArrayTable) {
     let a = table.mutableA!
-    XCTAssertEqual(a.a, 12.34)
-    XCTAssertEqual(a.b.count, 15)
+    #expect(a.a == 12.34)
+    #expect(a.b.count == 15)
     var sum: Int32 = 0
     for i in a.b.startIndex..<a.b.endIndex {
       sum += a.b[i]
     }
-    XCTAssertEqual(sum, 120)
-    XCTAssertEqual(a.c, -127)
-    XCTAssertEqual(a.d.count, 2)
+    #expect(sum == 120)
+    #expect(a.c == -127)
+    #expect(a.d.count == 2)
     let nestedStruct1 = a.d[0]
 
-    XCTAssertEqual(nestedStruct1.a.reduce(0) { $0 + $1 }, 1)
-    XCTAssertEqual(nestedStruct1.b, .a)
-    XCTAssertEqual(nestedStruct1.c[0], .c)
-    XCTAssertEqual(nestedStruct1.c[1], .b)
+    #expect(nestedStruct1.a.reduce(0) { $0 + $1 } == 1)
+    #expect(nestedStruct1.b == .a)
+    #expect(nestedStruct1.c[0] == .c)
+    #expect(nestedStruct1.c[1] == .b)
 
     let nestedStruct2 = a.d[1]
-    XCTAssertEqual(nestedStruct2.a.reduce(0) { $0 + $1 }, -1)
-    XCTAssertEqual(nestedStruct2.b, .b)
-    XCTAssertEqual(nestedStruct2.c[0], .b)
-    XCTAssertEqual(nestedStruct2.c[1], .a)
-    XCTAssertEqual(nestedStruct2.d[0], -0x1122334455667788)
-    XCTAssertEqual(nestedStruct2.d[1], 0x1122334455667788)
+    #expect(nestedStruct2.a.reduce(0) { $0 + $1 } == -1)
+    #expect(nestedStruct2.b == .b)
+    #expect(nestedStruct2.c[0] == .b)
+    #expect(nestedStruct2.c[1] == .a)
+    #expect(nestedStruct2.d[0] == -0x1122334455667788)
+    #expect(nestedStruct2.d[1] == 0x1122334455667788)
 
-    XCTAssertTrue(a.mutate(b: 1000, at: 0))
-    XCTAssertTrue(a.mutate(b: 2000, at: 1))
+    #expect(a.mutate(b: 1000, at: 0) == true)
+    #expect(a.mutate(b: 2000, at: 1) == true)
 
-    XCTAssertTrue(nestedStruct2.mutate(c: .a, at: 0))
-    XCTAssertTrue(nestedStruct2.mutate(c: .b, at: 1))
+    #expect(nestedStruct2.mutate(c: .a, at: 0) == true)
+    #expect(nestedStruct2.mutate(c: .b, at: 1) == true)
 
-    XCTAssertEqual(nestedStruct2.c[0], .a)
-    XCTAssertEqual(nestedStruct2.c[1], .b)
+    #expect(nestedStruct2.c[0] == .a)
+    #expect(nestedStruct2.c[1] == .b)
 
-    XCTAssertTrue(nestedStruct2.mutate(d: 0, at: 0))
-    XCTAssertTrue(nestedStruct2.mutate(d: 0, at: 1))
+    #expect(nestedStruct2.mutate(d: 0, at: 0) == true)
+    #expect(nestedStruct2.mutate(d: 0, at: 1) == true)
 
-    XCTAssertEqual(nestedStruct2.d.reduce(0) { $0 + $1 }, 0)
+    #expect(nestedStruct2.d.reduce(0) { $0 + $1 } == 0)
 
     let nativeStruct = table.a?.d[1]
 
-    XCTAssertEqual(nativeStruct?.c[0], .a)
-    XCTAssertEqual(nativeStruct?.c[1], .b)
+    #expect(nativeStruct?.c[0] == .a)
+    #expect(nativeStruct?.c[1] == .b)
 
-    XCTAssertEqual(nativeStruct?.d[0], 0)
-    XCTAssertEqual(nativeStruct?.d[1], 0)
+    #expect(nativeStruct?.d[0] == 0)
+    #expect(nativeStruct?.d[1] == 0)
 
-    XCTAssertTrue(a.mutate(b: 1, at: 0))
-    XCTAssertTrue(a.mutate(b: 2, at: 1))
+    #expect(a.mutate(b: 1, at: 0) == true)
+    #expect(a.mutate(b: 2, at: 1) == true)
 
-    XCTAssertTrue(nestedStruct2.mutate(c: .b, at: 0))
-    XCTAssertTrue(nestedStruct2.mutate(c: .a, at: 1))
+    #expect(nestedStruct2.mutate(c: .b, at: 0) == true)
+    #expect(nestedStruct2.mutate(c: .a, at: 1) == true)
 
-    XCTAssertTrue(nestedStruct2.mutate(d: -0x1122334455667788, at: 0))
-    XCTAssertTrue(nestedStruct2.mutate(d: 0x1122334455667788, at: 1))
+    #expect(nestedStruct2.mutate(d: -0x1122334455667788, at: 0) == true)
+    #expect(nestedStruct2.mutate(d: 0x1122334455667788, at: 1) == true)
   }
 
+  @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
   private func createArrayTable() -> [UInt8] {
     var builder = FlatBufferBuilder(initialSize: 1024)
 
@@ -233,4 +246,3 @@ extension InlineArray: @retroactive Equatable where Element: Equatable {
 }
 
 #endif
-

tests/swift/Tests/Flatbuffers/FlatBuffersMonsterWriterTests.swift

@@ -15,7 +15,7 @@
  */
 
 import Foundation
-import XCTest
+import Testing
 
 @testable import FlatBuffers
 
@@ -24,8 +24,9 @@ typealias Monster = MyGame_Example_Monster
 typealias Vec3 = MyGame_Example_Vec3
 typealias Stat = MyGame_Example_Stat
 
-class FlatBuffersMonsterWriterTests: XCTestCase {
+struct FlatBuffersMonsterWriterTests {
 
+  @Test
   func testData() {
     // swiftformat:disable all
     let data = Data([
@@ -47,12 +48,13 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readVerifiedMonster(fb: _data)
   }
 
+  @Test
   func testReadFromOtherLanguages() {
     let path = {
       #if os(macOS)
       // Gets the current path of this test file then
       // strips out the nested directories.
-      let filePath = URL(filePath: #file)
+      let filePath = URL(filePath: #filePath)
         .deletingLastPathComponent()
       return filePath.absoluteString
       #else
@@ -71,6 +73,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readVerifiedMonster(fb: _data)
   }
 
+  @Test
   func testCreateMonsterData() {
     let bytes = createMonster(withPrefix: false)
     var buffer = ByteBuffer(data: bytes.data)
@@ -80,30 +83,32 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readMonster(monster: monster)
   }
 
+  @Test(.bug("https://github.com/google/flatbuffers/issues/8642"))
   func testCreateMonsterResetTests() {
     var builder = createMonster(withPrefix: false)
     var buffer = ByteBuffer(data: builder.data)
     let monster: MyGame_Example_Monster = getRoot(byteBuffer: &buffer)
     readMonster(monster: monster)
     builder.clear()
-    XCTAssertEqual(builder.capacity, 1)
-    XCTAssertEqual(builder.size, 0)
+    #expect(builder.capacity == 1)
+    #expect(builder.size == 0)
 
     write(fbb: &builder, prefix: false)
     var _buffer = ByteBuffer(data: builder.data)
-    XCTAssertEqual(_buffer.capacity, 304)
+    #expect(_buffer.capacity == 304)
     let _monster: MyGame_Example_Monster = getRoot(byteBuffer: &_buffer)
     readMonster(monster: _monster)
     builder.clear(keepingCapacity: true)
-    XCTAssertEqual(builder.capacity, 512)
-    XCTAssertEqual(builder.size, 0)
+    #expect(builder.capacity == 512)
+    #expect(builder.size == 0)
   }
 
+  @Test
   func testCreateMonster() {
     let bytes = createMonster(withPrefix: false)
     // swiftformat:disable all
-    XCTAssertEqual(
-      bytes.sizedByteArray,
+    #expect(
+      bytes.sizedByteArray ==
       [
         48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28,
         0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0,
@@ -127,11 +132,12 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readMonster(monster: monster)
   }
 
+  @Test
   func testCreateMonsterResizedBuffer() {
     let bytes = createMonster(withPrefix: false)
     // swiftformat:disable all
-    XCTAssertEqual(
-      bytes.sizedByteArray,
+    #expect(
+      bytes.sizedByteArray ==
       [
         48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28,
         0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0,
@@ -150,11 +156,12 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readVerifiedMonster(fb: bytes.sizedBuffer)
   }
 
+  @Test
   func testCreateMonsterPrefixed() {
     let bytes = createMonster(withPrefix: true)
     // swiftformat:disable all
-    XCTAssertEqual(
-      bytes.sizedByteArray,
+    #expect(
+      bytes.sizedByteArray ==
       [
         44, 1, 0, 0, 44, 0, 0, 0, 77, 79, 78, 83, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28,
         0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0,
@@ -175,6 +182,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer))
   }
 
+  @Test
   func testCreateMonsterUsingCreateMonsterMethodWithNilPos() {
     var fbb = FlatBufferBuilder(initialSize: 1)
     let name = fbb.create(string: "Frodo")
@@ -184,10 +192,11 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     fbb.finish(offset: root)
     var buffer = fbb.sizedBuffer
     let newMonster: Monster = getRoot(byteBuffer: &buffer)
-    XCTAssertNil(newMonster.pos)
-    XCTAssertEqual(newMonster.name, "Frodo")
+    #expect(newMonster.pos == nil)
+    #expect(newMonster.name == "Frodo")
   }
 
+  @Test
   func testCreateMonsterUsingCreateMonsterMethodWithPosX() {
     var fbb = FlatBufferBuilder(initialSize: 1)
     let name = fbb.create(string: "Barney")
@@ -207,10 +216,11 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
 
     var buffer = fbb.sizedBuffer
     let newMonster: Monster = getRoot(byteBuffer: &buffer)
-    XCTAssertEqual(newMonster.pos!.x, 10)
-    XCTAssertEqual(newMonster.name, "Barney")
+    #expect(newMonster.pos!.x == 10)
+    #expect(newMonster.name == "Barney")
   }
 
+  @Test
   func testReadMonsterFromUnsafePointerWithoutCopying() {
     // swiftformat:disable all
     var array: [UInt8] = [
@@ -242,6 +252,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readObjectApi(monster: unpacked)
   }
 
+  @Test
   func testArrayOfBools() {
     let boolArray = [false, true, false, true, false, true, false]
     var fbb = FlatBufferBuilder(initialSize: 1)
@@ -257,37 +268,41 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     let monster: Monster = getRoot(byteBuffer: &buffer)
     let values = monster.testarrayofbools
 
-    XCTAssertEqual(boolArray.count, values.count)
+    #expect(boolArray.count == values.count)
 
     for (index, bool) in monster.testarrayofbools.enumerated() {
-      XCTAssertEqual(bool, boolArray[index])
+      #expect(bool == boolArray[index])
     }
   }
 
   func readVerifiedMonster(fb: ByteBuffer) {
     var byteBuffer = fb
-    XCTAssertNoThrow(
+    do {
       try readMonster(
         monster: getCheckedRoot(
-          byteBuffer: &byteBuffer) as MyGame_Example_Monster))
+          byteBuffer: &byteBuffer) as MyGame_Example_Monster)
+    } catch {
+      Issue.record(error)
+    }
   }
 
+  @Test(.bug("https://github.com/google/flatbuffers/issues/8133"))
   func testUnalignedRead() {
     // Aligned read
     let fbb = createMonster(withPrefix: false)
     let testAligned: () -> Bool = {
       var buffer = fbb.sizedBuffer
       var monster: Monster = getRoot(byteBuffer: &buffer)
-      self.readFlatbufferMonster(monster: &monster)
+      readFlatbufferMonster(monster: &monster)
       return true
     }
-    XCTAssertEqual(testAligned(), true)
+    #expect(testAligned() == true)
     let testUnaligned: () -> Bool = {
       var bytes: [UInt8] = [0x00]
       bytes.append(contentsOf: fbb.sizedByteArray)
       return bytes.withUnsafeMutableBytes { ptr in
         guard var baseAddress = ptr.baseAddress else {
-          XCTFail("Base pointer is not defined")
+          Issue.record("Base pointer is not defined")
           return false
         }
         baseAddress = baseAddress.advanced(by: 1)
@@ -296,13 +311,14 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
           assumingMemoryBound: unlignedPtr,
           capacity: ptr.count - 1)
         var monster: Monster = getRoot(byteBuffer: &bytes)
-        self.readFlatbufferMonster(monster: &monster)
+        readFlatbufferMonster(monster: &monster)
         return true
       }
     }
-    XCTAssertEqual(testUnaligned(), true)
+    #expect(testUnaligned() == true)
   }
 
+  @Test
   func testReadingRemovedSizeUnalignedBuffer() {
     // Aligned read
     let fbb = createMonster(withPrefix: true)
@@ -311,7 +327,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
       bytes.append(contentsOf: fbb.sizedByteArray)
       return bytes.withUnsafeMutableBytes { ptr in
         guard var baseAddress = ptr.baseAddress else {
-          XCTFail("Base pointer is not defined")
+          Issue.record("Base pointer is not defined")
           return false
         }
         baseAddress = baseAddress.advanced(by: 1)
@@ -321,32 +337,34 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
           capacity: ptr.count - 1)
         var newBuf = FlatBuffersUtils.removeSizePrefix(bb: bytes)
         var monster: Monster = getRoot(byteBuffer: &newBuf)
-        self.readFlatbufferMonster(monster: &monster)
+        readFlatbufferMonster(monster: &monster)
         return true
       }
     }
-    XCTAssertEqual(testUnaligned(), true)
+    #expect(testUnaligned() == true)
   }
 
+  @Test
   func testCreateMessage() {
     let fbb = createMonster(withPrefix: false)
     let byteBuffer = fbb.buffer
-    let firstMessage = Message<Monster>(byteBuffer: byteBuffer)
+    let firstMessage = GRPCMessage<Monster>(byteBuffer: byteBuffer)
     firstMessage.withUnsafeReadableBytes { ptr in
       var bytes = ByteBuffer(contiguousBytes: ptr, count: ptr.count)
       var monster: Monster = getRoot(byteBuffer: &bytes)
-      self.readFlatbufferMonster(monster: &monster)
+      readFlatbufferMonster(monster: &monster)
     }
 
     let secondByteBuffer = fbb.sizedBuffer
-    let secondMessage = Message<Monster>(byteBuffer: secondByteBuffer)
+    let secondMessage = GRPCMessage<Monster>(byteBuffer: secondByteBuffer)
     secondMessage.withUnsafeReadableBytes { ptr in
       var bytes = ByteBuffer(contiguousBytes: ptr, count: ptr.count)
       var monster: Monster = getRoot(byteBuffer: &bytes)
-      self.readFlatbufferMonster(monster: &monster)
+      readFlatbufferMonster(monster: &monster)
     }
   }
 
+  @Test
   func testForceRetainedObject() {
     let byteBuffer = {
       // swiftformat:disable all
@@ -452,95 +470,95 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     var fb = fb
 
     let monster: Monster = getRoot(byteBuffer: &fb)
-    XCTAssertFalse(monster.mutate(mana: 10))
-    XCTAssertEqual(monster.testarrayoftables[0].name, "Barney")
-    XCTAssertEqual(monster.testarrayoftables[1].name, "Frodo")
-    XCTAssertEqual(monster.testarrayoftables[2].name, "Wilma")
+    #expect(monster.mutate(mana: 10) == false)
+    #expect(monster.testarrayoftables[0].name == "Barney")
+    #expect(monster.testarrayoftables[1].name == "Frodo")
+    #expect(monster.testarrayoftables[2].name == "Wilma")
 
     // Example of searching for a table by the key
-    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo"))
-    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney"))
-    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma"))
+    #expect(monster.testarrayoftablesBy(key: "Frodo") != nil)
+    #expect(monster.testarrayoftablesBy(key: "Barney") != nil)
+    #expect(monster.testarrayoftablesBy(key: "Wilma") != nil)
 
-    XCTAssertEqual(monster.testType, .monster)
+    #expect(monster.testType == .monster)
 
-    XCTAssertEqual(monster.mutate(inventory: 1, at: 0), true)
-    XCTAssertEqual(monster.mutate(inventory: 2, at: 1), true)
-    XCTAssertEqual(monster.mutate(inventory: 3, at: 2), true)
-    XCTAssertEqual(monster.mutate(inventory: 4, at: 3), true)
-    XCTAssertEqual(monster.mutate(inventory: 5, at: 4), true)
+    #expect(monster.mutate(inventory: 1, at: 0) == true)
+    #expect(monster.mutate(inventory: 2, at: 1) == true)
+    #expect(monster.mutate(inventory: 3, at: 2) == true)
+    #expect(monster.mutate(inventory: 4, at: 3) == true)
+    #expect(monster.mutate(inventory: 5, at: 4) == true)
 
     for i in 0..<monster.inventory.count {
-      XCTAssertEqual(monster.inventory[i], Byte(i + 1))
+      #expect(monster.inventory[i] == Byte(i + 1))
     }
 
-    XCTAssertEqual(monster.mutate(inventory: 0, at: 0), true)
-    XCTAssertEqual(monster.mutate(inventory: 1, at: 1), true)
-    XCTAssertEqual(monster.mutate(inventory: 2, at: 2), true)
-    XCTAssertEqual(monster.mutate(inventory: 3, at: 3), true)
-    XCTAssertEqual(monster.mutate(inventory: 4, at: 4), true)
+    #expect(monster.mutate(inventory: 0, at: 0) == true)
+    #expect(monster.mutate(inventory: 1, at: 1) == true)
+    #expect(monster.mutate(inventory: 2, at: 2) == true)
+    #expect(monster.mutate(inventory: 3, at: 3) == true)
+    #expect(monster.mutate(inventory: 4, at: 4) == true)
 
     let vec = monster.mutablePos
-    XCTAssertEqual(vec?.x, 1)
-    XCTAssertTrue(vec?.mutate(x: 55.0) ?? false)
-    XCTAssertTrue(vec?.mutate(test1: 55) ?? false)
-    XCTAssertEqual(vec?.x, 55.0)
-    XCTAssertEqual(vec?.test1, 55.0)
-    XCTAssertTrue(vec?.mutate(x: 1) ?? false)
-    XCTAssertEqual(vec?.x, 1)
-    XCTAssertTrue(vec?.mutate(test1: 3) ?? false)
+    #expect(vec?.x == 1)
+    #expect(vec?.mutate(x: 55.0) == true)
+    #expect(vec?.mutate(test1: 55) == true)
+    #expect(vec?.x == 55.0)
+    #expect(vec?.test1 == 55.0)
+    #expect(vec?.mutate(x: 1) == true)
+    #expect(vec?.x == 1)
+    #expect(vec?.mutate(test1: 3) == true)
 
     let mutableTest4 = monster.mutableTest4
     let orignalValues = mutableTest4[0].a
-    XCTAssertEqual(mutableTest4[0].mutate(a: 100), true)
-    XCTAssertNotEqual(monster.test4[0].a, orignalValues)
-    XCTAssertEqual(monster.test4[0].a, 100)
-    XCTAssertEqual(mutableTest4[0].mutate(a: orignalValues), true)
+    #expect(mutableTest4[0].mutate(a: 100) == true)
+    #expect(monster.test4[0].a != orignalValues)
+    #expect(monster.test4[0].a == 100)
+    #expect(mutableTest4[0].mutate(a: orignalValues) == true)
   }
 
   func readFlatbufferMonster(monster: inout MyGame_Example_Monster) {
-    XCTAssertEqual(monster.hp, 80)
-    XCTAssertEqual(monster.mana, 150)
-    XCTAssertEqual(monster.name, "MyMonster")
+    #expect(monster.hp == 80)
+    #expect(monster.mana == 150)
+    #expect(monster.name == "MyMonster")
     let pos = monster.pos
-    XCTAssertEqual(pos?.x, 1)
-    XCTAssertEqual(pos?.y, 2)
-    XCTAssertEqual(pos?.z, 3)
-    XCTAssertEqual(pos?.test1, 3)
-    XCTAssertEqual(pos?.test2, .green)
+    #expect(pos?.x == 1)
+    #expect(pos?.y == 2)
+    #expect(pos?.z == 3)
+    #expect(pos?.test1 == 3)
+    #expect(pos?.test2 == .green)
     let test = pos?.test3
-    XCTAssertEqual(test?.a, 5)
-    XCTAssertEqual(test?.b, 6)
-    XCTAssertEqual(monster.testType, .monster)
+    #expect(test?.a == 5)
+    #expect(test?.b == 6)
+    #expect(monster.testType == .monster)
     let monster2 = monster.test(type: Monster.self)
-    XCTAssertEqual(monster2?.name, "Fred")
+    #expect(monster2?.name == "Fred")
 
-    XCTAssertEqual(monster.mutate(mana: 10), false)
+    #expect(monster.mutate(mana: 10) == false)
 
-    XCTAssertEqual(monster.mana, 150)
-    XCTAssertEqual(monster.inventory.count, 5)
+    #expect(monster.mana == 150)
+    #expect(monster.inventory.count == 5)
     var sum: Byte = 0
     for inventory in monster.inventory {
       sum += inventory
     }
-    XCTAssertEqual(sum, 10)
+    #expect(sum == 10)
 
     monster.withUnsafePointerToInventory { ptr, count in
       var sum: UInt8 = 0
       for pointee in ptr.startIndex..<ptr.endIndex {
         sum += ptr[pointee]
       }
-      XCTAssertEqual(sum, 10)
+      #expect(sum == 10)
     }
 
-    XCTAssertEqual(monster.test4.count, 2)
+    #expect(monster.test4.count == 2)
 
     let test4 = monster.test4
     var sum0 = 0
     for test0 in test4 {
       sum0 += Int(test0.a) + Int(test0.b)
     }
-    XCTAssertEqual(sum0, 100)
+    #expect(sum0 == 100)
 
     monster.withUnsafePointerToTest4 { ptr, count in
       guard let ptr = ptr.baseAddress else { return }
@@ -556,7 +574,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
         pointerSum += Int(bindedMemory[pointee].a) +
           Int(bindedMemory[pointee].b)
       }
-      XCTAssertEqual(pointerSum, 100)
+      #expect(pointerSum == 100)
     }
 
     let mutableTest4 = monster.mutableTest4
@@ -564,87 +582,84 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     for test0 in mutableTest4 {
       sum2 += Int(test0.a) + Int(test0.b)
     }
-    XCTAssertEqual(sum2, 100)
+    #expect(sum2 == 100)
 
     let stringArray = monster.testarrayofstring
-    XCTAssertEqual(stringArray.count, 2)
-    XCTAssertEqual(stringArray[0], "test1")
-    XCTAssertEqual(stringArray[1], "test2")
-    XCTAssertEqual(monster.testbool, true)
+    #expect(stringArray.count == 2)
+    #expect(stringArray[0] == "test1")
+    #expect(stringArray[1] == "test2")
+    #expect(monster.testbool == true)
 
     let array = monster.nameSegmentArray
-    XCTAssertEqual(String(bytes: array ?? [], encoding: .utf8), "MyMonster")
+    #expect(String(bytes: array ?? [], encoding: .utf8) == "MyMonster")
 
     if 0 == monster.testarrayofbools.count {
-      XCTAssertEqual(monster.testarrayofbools.isEmpty, true)
+      #expect(monster.testarrayofbools.isEmpty == true)
     } else {
-      XCTAssertEqual(monster.testarrayofbools.isEmpty, false)
+      #expect(monster.testarrayofbools.isEmpty == false)
     }
   }
 
   func readObjectApi(monster: MyGame_Example_MonsterT) {
-    XCTAssertEqual(monster.hp, 80)
-    XCTAssertEqual(monster.mana, 150)
-    XCTAssertEqual(monster.name, "MyMonster")
+    #expect(monster.hp == 80)
+    #expect(monster.mana == 150)
+    #expect(monster.name == "MyMonster")
     let pos = monster.pos
-    XCTAssertEqual(pos?.x, 1)
-    XCTAssertEqual(pos?.y, 2)
-    XCTAssertEqual(pos?.z, 3)
-    XCTAssertEqual(pos?.test1, 3)
-    XCTAssertEqual(pos?.test2, .green)
+    #expect(pos?.x == 1)
+    #expect(pos?.y == 2)
+    #expect(pos?.z == 3)
+    #expect(pos?.test1 == 3)
+    #expect(pos?.test2 == .green)
     let test = pos?.test3
-    XCTAssertEqual(test?.a, 5)
-    XCTAssertEqual(test?.b, 6)
+    #expect(test?.a == 5)
+    #expect(test?.b == 6)
     let monster2 = monster.test?.value as? MyGame_Example_MonsterT
-    XCTAssertEqual(monster2?.name, "Fred")
-    XCTAssertEqual(monster.mana, 150)
+    #expect(monster2?.name == "Fred")
+    #expect(monster.mana == 150)
     monster.mana = 10
-    XCTAssertEqual(monster.mana, 10)
+    #expect(monster.mana == 10)
     monster.mana = 150
-    XCTAssertEqual(monster.mana, 150)
+    #expect(monster.mana == 150)
 
-    XCTAssertEqual(monster.inventory.count, 5)
+    #expect(monster.inventory.count == 5)
     var sum: Byte = 0
     for i in monster.inventory {
       sum += i
     }
-    XCTAssertEqual(sum, 10)
-    XCTAssertEqual(monster.test4.count, 2)
+    #expect(sum == 10)
+    #expect(monster.test4.count == 2)
     var sum0 = 0
     for test in monster.test4 {
       sum0 += Int(test.a) + Int(test.b)
     }
-    XCTAssertEqual(sum0, 100)
-    XCTAssertEqual(monster.testbool, true)
+    #expect(sum0 == 100)
+    #expect(monster.testbool == true)
   }
 
-  func testEncoding() {
+  @Test
+  func testEncoding() throws {
     let fbb = createMonster(withPrefix: false)
     var sizedBuffer = fbb.sizedBuffer
-    do {
-      struct Test: Decodable {
-        struct Pos: Decodable {
-          let x, y, z: Int
-        }
-        let hp: Int
-        let inventory: [UInt8]
-        let name: String
-        let pos: Pos
+    struct Test: Decodable {
+      struct Pos: Decodable {
+        let x, y, z: Int
       }
-      let reader: Monster = try getCheckedRoot(byteBuffer: &sizedBuffer)
-      let encoder = JSONEncoder()
-      encoder.keyEncodingStrategy = .convertToSnakeCase
-      let data = try encoder.encode(reader)
-      let decoder = JSONDecoder()
-      decoder.keyDecodingStrategy = .convertFromSnakeCase
-      let value = try decoder.decode(Test.self, from: data)
-      XCTAssertEqual(value.name, "MyMonster")
-      XCTAssertEqual(value.pos.x, 1)
-      XCTAssertEqual(value.pos.y, 2)
-      XCTAssertEqual(value.pos.z, 3)
-    } catch {
-      XCTFail(error.localizedDescription)
+      let hp: Int
+      let inventory: [UInt8]
+      let name: String
+      let pos: Pos
     }
+    let reader: Monster = try getCheckedRoot(byteBuffer: &sizedBuffer)
+    let encoder = JSONEncoder()
+    encoder.keyEncodingStrategy = .convertToSnakeCase
+    let data = try encoder.encode(reader)
+    let decoder = JSONDecoder()
+    decoder.keyDecodingStrategy = .convertFromSnakeCase
+    let value = try decoder.decode(Test.self, from: data)
+    #expect(value.name == "MyMonster")
+    #expect(value.pos.x == 1)
+    #expect(value.pos.y == 2)
+    #expect(value.pos.z == 3)
   }
 
   var jsonData: String {
@@ -653,6 +668,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     """
   }
 
+  @Test
   func testContiguousBytes() {
     let byteArray: [UInt8] = [3, 1, 4, 1, 5, 9]
     var fbb = FlatBufferBuilder(initialSize: 1)
@@ -670,7 +686,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     monster.withUnsafePointerToInventory { ptr, count in
       let array = Array(ptr)
       for (index, value) in values.enumerated() {
-        XCTAssertEqual(array[index], value)
+        #expect(array[index] == value)
       }
     }
   }

tests/swift/Tests/Flatbuffers/FlatBuffersNanInfTests.swift

@@ -14,11 +14,59 @@
  * limitations under the License.
  */
 
-import XCTest
+import Foundation
+import Testing
 
 @testable import FlatBuffers
 
-final class FlatBuffersNanInfTests: XCTestCase {
+struct FlatBuffersNanInfTests {
+
+  @Test
+  func testInfNanBinary() {
+    let fbb = createTestTable()
+    let data = fbb.sizedByteArray
+
+    var buffer = ByteBuffer(bytes: data)
+    let table: Swift_Tests_NanInfTable = getRoot(byteBuffer: &buffer)
+    #expect(table.defaultNan.isNaN)
+    #expect(table.defaultInf == .infinity)
+    #expect(table.defaultNinf == -.infinity)
+    #expect(table.valueNan.isNaN)
+    #expect(table.valueInf == .infinity)
+    #expect(table.valueNinf == -.infinity)
+    #expect(table.value == 100.0)
+  }
+
+  @Test
+  func testInfNanJSON() throws {
+    let fbb = createTestTable()
+    var bb = fbb.sizedBuffer
+    struct Test: Decodable {
+      let valueInf: Double
+      let value: Int
+      let valueNan: Double
+      let valueNinf: Double
+    }
+    let reader: Swift_Tests_NanInfTable = try getCheckedRoot(byteBuffer: &bb)
+    let encoder = JSONEncoder()
+    encoder.keyEncodingStrategy = .convertToSnakeCase
+    encoder.nonConformingFloatEncodingStrategy =
+      .convertToString(
+        positiveInfinity: "inf",
+        negativeInfinity: "-inf",
+        nan: "nan")
+    let data = try encoder.encode(reader)
+    let decoder = JSONDecoder()
+    decoder.nonConformingFloatDecodingStrategy = .convertFromString(
+      positiveInfinity: "inf",
+      negativeInfinity: "-inf",
+      nan: "nan")
+    decoder.keyDecodingStrategy = .convertFromSnakeCase
+    let value = try decoder.decode(Test.self, from: data)
+    #expect(value.value == 100)
+    #expect(value.valueInf == .infinity)
+    #expect(value.valueNinf == -.infinity)
+  }
 
   func createTestTable() -> FlatBufferBuilder {
     var fbb = FlatBufferBuilder()
@@ -31,54 +79,4 @@ final class FlatBuffersNanInfTests: XCTestCase {
     fbb.finish(offset: msg)
     return fbb
   }
-
-  func testInfNanBinary() {
-    let fbb = createTestTable()
-    let data = fbb.sizedByteArray
-
-    var buffer = ByteBuffer(bytes: data)
-    let table: Swift_Tests_NanInfTable = getRoot(byteBuffer: &buffer)
-    XCTAssert(table.defaultNan.isNaN)
-    XCTAssertEqual(table.defaultInf, .infinity)
-    XCTAssertEqual(table.defaultNinf, -.infinity)
-    XCTAssert(table.valueNan.isNaN)
-    XCTAssertEqual(table.valueInf, .infinity)
-    XCTAssertEqual(table.valueNinf, -.infinity)
-    XCTAssertEqual(table.value, 100.0)
-  }
-
-  func testInfNanJSON() {
-    let fbb = createTestTable()
-    var bb = fbb.sizedBuffer
-    do {
-      struct Test: Decodable {
-        let valueInf: Double
-        let value: Int
-        let valueNan: Double
-        let valueNinf: Double
-      }
-      let reader: Swift_Tests_NanInfTable = try getCheckedRoot(byteBuffer: &bb)
-      let encoder = JSONEncoder()
-      encoder.keyEncodingStrategy = .convertToSnakeCase
-      encoder.nonConformingFloatEncodingStrategy =
-        .convertToString(
-          positiveInfinity: "inf",
-          negativeInfinity: "-inf",
-          nan: "nan")
-      let data = try encoder.encode(reader)
-      let decoder = JSONDecoder()
-      decoder.nonConformingFloatDecodingStrategy = .convertFromString(
-        positiveInfinity: "inf",
-        negativeInfinity: "-inf",
-        nan: "nan")
-      decoder.keyDecodingStrategy = .convertFromSnakeCase
-      let value = try decoder.decode(Test.self, from: data)
-      XCTAssertEqual(value.value, 100)
-      XCTAssertEqual(value.valueInf, .infinity)
-      XCTAssertEqual(value.valueNinf, -.infinity)
-    } catch {
-      XCTFail(error.localizedDescription)
-    }
-  }
-
 }

tests/swift/Tests/Flatbuffers/FlatBuffersStructsTests.swift

@@ -14,12 +14,13 @@
  * limitations under the License.
  */
 
-import XCTest
+import Testing
 
 @testable import FlatBuffers
 
-final class FlatBuffersStructsTests: XCTestCase {
+struct FlatBuffersStructsTests {
 
+  @Test
   func testWritingAndMutatingBools() {
     var fbb = FlatBufferBuilder()
     let start = TestMutatingBool.startTestMutatingBool(&fbb)
@@ -30,11 +31,11 @@ final class FlatBuffersStructsTests: XCTestCase {
     var buffer = fbb.sizedBuffer
     let testMutatingBool: TestMutatingBool = getRoot(byteBuffer: &buffer)
     let property = testMutatingBool.mutableB
-    XCTAssertEqual(property?.property, false)
+    #expect(property?.property == false)
     property?.mutate(property: false)
-    XCTAssertEqual(property?.property, false)
+    #expect(property?.property == false)
     property?.mutate(property: true)
-    XCTAssertEqual(property?.property, true)
+    #expect(property?.property == true)
   }
 
 }

tests/swift/Tests/Flatbuffers/FlatBuffersTests.swift

@@ -14,44 +14,49 @@
  * limitations under the License.
  */
 
-import XCTest
+import Testing
 
 @testable import Common
 @testable import FlatBuffers
 
-final class FlatBuffersTests: XCTestCase {
+struct FlatBuffersTests {
 
   let country = "Norway"
 
-  func testEndian() { XCTAssertEqual(isLitteEndian, true) }
+  @Test
+  func testEndian() { #expect(isLitteEndian == true) }
 
+  @Test
   func testOffset() {
     let o = Offset()
     let b = Offset(offset: 1)
-    XCTAssertEqual(o.isEmpty, true)
-    XCTAssertEqual(b.isEmpty, false)
+    #expect(o.isEmpty == true)
+    #expect(b.isEmpty == false)
   }
 
+  @Test
   func testCreateString() {
     let helloWorld = "Hello, world!"
     var b = FlatBufferBuilder(initialSize: 16)
-    XCTAssertEqual(b.create(string: country).o, 12)
-    XCTAssertEqual(b.create(string: helloWorld).o, 32)
+    #expect(b.create(string: country).o == 12)
+    #expect(b.create(string: helloWorld).o == 32)
     b.clear()
-    XCTAssertEqual(b.create(string: helloWorld).o, 20)
-    XCTAssertEqual(b.create(string: country).o, 32)
+    #expect(b.create(string: helloWorld).o == 20)
+    #expect(b.create(string: country).o == 32)
     b.clear()
-    XCTAssertEqual(b.create(string: String(repeating: "a", count: 257)).o, 264)
+    #expect(b.create(string: String(repeating: "a", count: 257)).o == 264)
   }
 
+  @Test
   func testStartTable() {
     var b = FlatBufferBuilder(initialSize: 16)
-    XCTAssertNoThrow(b.startTable(with: 0))
+    _ = b.startTable(with: 0)
     b.clear()
-    XCTAssertEqual(b.create(string: country).o, 12)
-    XCTAssertEqual(b.startTable(with: 0), 12)
+    #expect(b.create(string: country).o == 12)
+    #expect(b.startTable(with: 0) == 12)
   }
 
+  @Test
   func testCreateFinish() {
     var b = FlatBufferBuilder(initialSize: 16)
     let countryOff = Country.createCountry(
@@ -66,9 +71,10 @@ final class FlatBuffersTests: XCTestCase {
       200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0,
     ]
     // swiftformat:enable all
-    XCTAssertEqual(b.sizedByteArray, v)
+    #expect(b.sizedByteArray == v)
   }
 
+  @Test
   func testCreateFinishWithPrefix() {
     var b = FlatBufferBuilder(initialSize: 16)
     let countryOff = Country.createCountry(
@@ -83,9 +89,10 @@ final class FlatBuffersTests: XCTestCase {
       100, 0, 0, 0, 200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0,
     ]
     // swiftformat:enable all
-    XCTAssertEqual(b.sizedByteArray, v)
+    #expect(b.sizedByteArray == v)
   }
 
+  @Test
   func testReadCountry() {
     // swiftformat:disable all
     let v: [UInt8] = [
@@ -95,18 +102,20 @@ final class FlatBuffersTests: XCTestCase {
     // swiftformat:enable all
     let buffer = ByteBuffer(bytes: v)
     let c = Country.getRootAsCountry(buffer)
-    XCTAssertEqual(c.lan, 100)
-    XCTAssertEqual(c.log, 200)
-    XCTAssertEqual(c.nameVector, [78, 111, 114, 119, 97, 121])
-    XCTAssertEqual(c.name, country)
+    #expect(c.lan == 100)
+    #expect(c.log == 200)
+    #expect(c.nameVector == [78, 111, 114, 119, 97, 121])
+    #expect(c.name == country)
   }
 
+  @Test
   func testWriteNullableStrings() {
     var b = FlatBufferBuilder()
-    XCTAssertTrue(b.create(string: nil).isEmpty)
-    XCTAssertTrue(b.createShared(string: nil).isEmpty)
+    #expect(b.create(string: nil).isEmpty)
+    #expect(b.createShared(string: nil).isEmpty)
   }
 
+  @Test
   func testWriteOptionalValues() {
     var b = FlatBufferBuilder()
     let root = optional_scalars_ScalarStuff.createScalarStuff(
@@ -121,16 +130,17 @@ final class FlatBuffersTests: XCTestCase {
     b.finish(offset: root)
     var buffer = b.sizedBuffer
     let scalarTable: optional_scalars_ScalarStuff = getRoot(byteBuffer: &buffer)
-    XCTAssertEqual(scalarTable.justI8, 80)
-    XCTAssertNil(scalarTable.maybeI8)
-    XCTAssertEqual(scalarTable.maybeBool, true)
-    XCTAssertEqual(scalarTable.defaultI8, 42)
-    XCTAssertEqual(scalarTable.justU8, 100)
-    XCTAssertEqual(scalarTable.maybeU8, 10)
-    XCTAssertEqual(scalarTable.justEnum, .one)
-    XCTAssertNil(scalarTable.maybeEnum)
+    #expect(scalarTable.justI8 == 80)
+    #expect(scalarTable.maybeI8 == nil)
+    #expect(scalarTable.maybeBool == true)
+    #expect(scalarTable.defaultI8 == 42)
+    #expect(scalarTable.justU8 == 100)
+    #expect(scalarTable.maybeU8 == 10)
+    #expect(scalarTable.justEnum == .one)
+    #expect(scalarTable.maybeEnum == nil)
   }
 
+  @Test
   func testAlignmentCrash() {
     var builder = FlatBufferBuilder(initialSize: 256)
 

tests/swift/Tests/Flatbuffers/FlatBuffersUnionTests.swift

@@ -14,12 +14,14 @@
  * limitations under the License.
  */
 
-import XCTest
+import Foundation
+import Testing
 
 @testable import FlatBuffers
 
-final class FlatBuffersUnionTests: XCTestCase {
+struct FlatBuffersUnionTests {
 
+  @Test
   func testCreateMonstor() {
 
     var b = FlatBufferBuilder(initialSize: 20)
@@ -36,8 +38,8 @@ final class FlatBuffersUnionTests: XCTestCase {
     b.finish(offset: root)
     let buffer = b.sizedByteArray
     // swiftformat:disable all
-    XCTAssertEqual(
-      buffer,
+    #expect(
+      buffer ==
       [
         16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 8, 0, 7, 0, 12, 0, 10, 0, 0, 0, 0, 0, 0, 1, 8, 0, 0, 0, 20,
         0, 0, 0, 1, 0, 0, 0, 12, 0, 0, 0, 8, 0, 12, 0, 8, 0, 6, 0, 8, 0, 0, 0, 0, 0, 5, 0, 4, 0, 0,
@@ -45,15 +47,16 @@ final class FlatBuffersUnionTests: XCTestCase {
       ])
     // swiftformat:enable all
     let monster = LocalMonster.getRootAsMonster(bb: ByteBuffer(bytes: buffer))
-    XCTAssertEqual(monster.weapon(at: 0)?.dmg, dmg)
-    XCTAssertEqual(monster.weapon(at: 0)?.name, str)
-    XCTAssertEqual(monster.weapon(at: 0)?.nameVector, [65, 120, 101])
+    #expect(monster.weapon(at: 0)?.dmg == dmg)
+    #expect(monster.weapon(at: 0)?.name == str)
+    #expect(monster.weapon(at: 0)?.nameVector == [65, 120, 101])
     let p: Weapon? = monster.equiped()
-    XCTAssertEqual(p?.dmg, dmg)
-    XCTAssertEqual(p?.name, str)
-    XCTAssertEqual(p?.nameVector, [65, 120, 101])
+    #expect(p?.dmg == dmg)
+    #expect(p?.name == str)
+    #expect(p?.nameVector == [65, 120, 101])
   }
 
+  @Test
   func testEndTableFinish() {
     var builder = FlatBufferBuilder(initialSize: 20)
     let sword = builder.create(string: "Sword")
@@ -84,8 +87,8 @@ final class FlatBuffersUnionTests: XCTestCase {
       path: path)
     builder.finish(offset: orc)
     // swiftformat:disable all
-    XCTAssertEqual(
-      builder.sizedByteArray,
+    #expect(
+      builder.sizedByteArray ==
       [
         32, 0, 0, 0, 0, 0, 26, 0, 48, 0, 36, 0, 0, 0, 34, 0, 28, 0, 0, 0, 24, 0, 23, 0, 16, 0, 15,
         0, 8, 0, 4, 0, 26, 0, 0, 0, 44, 0, 0, 0, 104, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 0, 0, 0, 0,
@@ -99,6 +102,7 @@ final class FlatBuffersUnionTests: XCTestCase {
     // swiftformat:enable all
   }
 
+  @Test
   func testEnumVector() {
     let vectorOfEnums: [ColorsNameSpace.RGB] = [.blue, .green]
 
@@ -109,8 +113,8 @@ final class FlatBuffersUnionTests: XCTestCase {
     let end = ColorsNameSpace.Monster.endMonster(&builder, start: start)
     builder.finish(offset: end)
     // swiftformat:disable all
-    XCTAssertEqual(
-      builder.sizedByteArray,
+    #expect(
+      builder.sizedByteArray ==
       [
         12, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 1, 0,
         0, 0,
@@ -118,12 +122,13 @@ final class FlatBuffersUnionTests: XCTestCase {
     // swiftformat:enable all
     let monster = ColorsNameSpace.Monster
       .getRootAsMonster(bb: builder.sizedBuffer)
-    XCTAssertEqual(monster.colorsCount, 2)
+    #expect(monster.colorsCount == 2)
     let colors = monster.colors
-    XCTAssertEqual(colors[0], .blue)
-    XCTAssertEqual(colors[1], .green)
+    #expect(colors[0] == .blue)
+    #expect(colors[1] == .green)
   }
 
+  @Test
   func testUnionVector() {
     var fb = FlatBufferBuilder()
 
@@ -149,30 +154,30 @@ final class FlatBuffersUnionTests: XCTestCase {
 
     var buffer = fb.sizedBuffer
     let movie: Movie = getRoot(byteBuffer: &buffer)
-    XCTAssertEqual(movie.charactersType.count, characterType.count)
-    XCTAssertEqual(movie.characters.count, characters.count)
+    #expect(movie.charactersType.count == characterType.count)
+    #expect(movie.characters.count == characters.count)
 
     let bufferCharactersType = movie.charactersType
     for (index, element) in bufferCharactersType.enumerated() {
-      XCTAssertEqual(element, characterType[index])
+      #expect(element == characterType[index])
     }
 
-    XCTAssertEqual(
-      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
-      7)
-    XCTAssertEqual(
-      movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage,
-      swordDmg)
-    XCTAssertEqual(
-      movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead,
-      2)
+    #expect(
+      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead ==
+        7)
+    #expect(
+      movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage ==
+        swordDmg)
+    #expect(
+      movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead ==
+        2)
 
     var objc: MovieT? = movie.unpack()
-    XCTAssertEqual(
-      movie.charactersType.count, objc?.characters.count ?? 0)
-    XCTAssertEqual(
-      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
-      (objc?.characters[0]?.value as? BookReader)?.booksRead)
+    #expect(
+      movie.charactersType.count == objc?.characters.count ?? 0)
+    #expect(
+      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead ==
+        (objc?.characters[0]?.value as? BookReader)?.booksRead)
     fb.clear()
     let newMovie = Movie.pack(&fb, obj: &objc)
     fb.finish(offset: newMovie)
@@ -180,17 +185,18 @@ final class FlatBuffersUnionTests: XCTestCase {
     var _buffer = fb.sizedBuffer
     let packedMovie: Movie = getRoot(byteBuffer: &_buffer)
 
-    XCTAssertEqual(
-      packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
-      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead)
-    XCTAssertEqual(
-      packedMovie.characters(at: 1, type: Attacker.self)?.swordAttackDamage,
-      movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage)
-    XCTAssertEqual(
-      packedMovie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead,
-      movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead)
+    #expect(
+      packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead ==
+        movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead)
+    #expect(
+      packedMovie.characters(at: 1, type: Attacker.self)?.swordAttackDamage ==
+        movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage)
+    #expect(
+      packedMovie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead ==
+        movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead)
   }
 
+  @Test
   func testStringUnion() {
     let string = "Awesome \\\\t\t\nstring!"
     var fb = FlatBufferBuilder()
@@ -214,30 +220,31 @@ final class FlatBuffersUnionTests: XCTestCase {
 
     var buffer = fb.sizedBuffer
     let movie: Movie = getRoot(byteBuffer: &buffer)
-    XCTAssertEqual(movie.mainCharacter(type: String.self), string)
-    XCTAssertEqual(
-      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
-      7)
-    XCTAssertEqual(movie.characters(at: 1, type: String.self), string)
+    #expect(movie.mainCharacter(type: String.self) == string)
+    #expect(
+      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead ==
+        7)
+    #expect(movie.characters(at: 1, type: String.self) == string)
 
     var objc: MovieT? = movie.unpack()
-    XCTAssertEqual(objc?.mainCharacter?.value as? String, string)
-    XCTAssertEqual((objc?.characters[0]?.value as? BookReader)?.booksRead, 7)
-    XCTAssertEqual(objc?.characters[1]?.value as? String, string)
+    #expect(objc?.mainCharacter?.value as? String == string)
+    #expect((objc?.characters[0]?.value as? BookReader)?.booksRead == 7)
+    #expect(objc?.characters[1]?.value as? String == string)
     fb.clear()
     let newMovie = Movie.pack(&fb, obj: &objc)
     fb.finish(offset: newMovie)
 
     var _buffer = fb.sizedBuffer
     let packedMovie: Movie = getRoot(byteBuffer: &_buffer)
-    XCTAssertEqual(packedMovie.mainCharacter(type: String.self), string)
-    XCTAssertEqual(
-      packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
-      7)
-    XCTAssertEqual(packedMovie.characters(at: 1, type: String.self), string)
+    #expect(packedMovie.mainCharacter(type: String.self) == string)
+    #expect(
+      packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead ==
+        7)
+    #expect(packedMovie.characters(at: 1, type: String.self) == string)
   }
 
-  func testEncoding() {
+  @Test
+  func testEncoding() throws {
     let string = "Awesome \\\\t\t\nstring!"
     var fb = FlatBufferBuilder()
 
@@ -265,16 +272,12 @@ final class FlatBuffersUnionTests: XCTestCase {
     Movie.finish(&fb, end: end)
 
     var sizedBuffer = fb.sizedBuffer
-    do {
-      let reader: Movie = try getCheckedRoot(byteBuffer: &sizedBuffer)
-      let encoder = JSONEncoder()
-      encoder.keyEncodingStrategy = .convertToSnakeCase
-      encoder.outputFormatting = [.sortedKeys]
-      let data = try encoder.encode(reader)
-      XCTAssertEqual(String(data: data, encoding: .utf8), jsonData)
-    } catch {
-      XCTFail(error.localizedDescription)
-    }
+    let reader: Movie = try getCheckedRoot(byteBuffer: &sizedBuffer)
+    let encoder = JSONEncoder()
+    encoder.keyEncodingStrategy = .convertToSnakeCase
+    encoder.outputFormatting = [.sortedKeys]
+    let data = try encoder.encode(reader)
+    #expect(String(data: data, encoding: .utf8) == jsonData)
   }
 
   var jsonData: String {

tests/swift/Tests/Flatbuffers/FlatBuffersVectorsTests.swift

@@ -14,12 +14,13 @@
  * limitations under the License.
  */
 
-import XCTest
+import Testing
 
 @testable import FlatBuffers
 
-final class FlatBuffersVectors: XCTestCase {
+struct FlatBuffersVectors {
 
+  @Test
   func testCreatingTwoCountries() {
     let norway = "Norway"
     let denmark = "Denmark"
@@ -40,8 +41,8 @@ final class FlatBuffersVectors: XCTestCase {
     let vectorOffset = b.createVector(ofOffsets: vector)
     b.finish(offset: vectorOffset)
     // swiftformat:disable all
-    XCTAssertEqual(
-      b.sizedByteArray,
+    #expect(
+      b.sizedByteArray ==
       [
         4, 0, 0, 0, 2, 0, 0, 0, 48, 0, 0, 0, 16, 0, 0, 0, 0, 0, 10, 0, 18, 0, 4, 0, 8, 0, 12, 0, 10,
         0, 0, 0, 40, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10,
@@ -51,18 +52,20 @@ final class FlatBuffersVectors: XCTestCase {
     // swiftformat:enable all
   }
 
+  @Test
   func testCreateIntArray() {
     let numbers: [Int32] = [1, 2, 3, 4, 5]
     var b = FlatBufferBuilder(initialSize: 20)
     let o = b.createVector(numbers, size: numbers.count)
     b.finish(offset: o)
     // swiftformat:disable all
-    XCTAssertEqual(
-      b.sizedByteArray,
+    #expect(
+      b.sizedByteArray ==
       [4, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0])
     // swiftformat:enable all
   }
 
+  @Test
   func testCreateStructArray() {
     struct Vec: NativeStruct {
       let x, y, z: Float32
@@ -76,8 +79,8 @@ final class FlatBuffersVectors: XCTestCase {
     let o = b.createVector(ofStructs: vector)
     b.finish(offset: o)
     // swiftformat:disable all
-    XCTAssertEqual(
-      b.sizedByteArray,
+    #expect(
+      b.sizedByteArray ==
       [
         4, 0, 0, 0, 3, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 128, 64, 0, 0, 160,
         64, 0, 0, 192, 64, 0, 0, 224, 64, 0, 0, 0, 65, 0, 0, 16, 65,
@@ -85,28 +88,31 @@ final class FlatBuffersVectors: XCTestCase {
     // swiftformat:enable all
   }
 
+  @Test
   func testCreateEmptyIntArray() {
     let numbers: [Int32] = []
     var b = FlatBufferBuilder(initialSize: 20)
     let o = b.createVector(numbers, size: numbers.count)
     b.finish(offset: o)
-    XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 0, 0, 0, 0])
+    #expect(b.sizedByteArray == [4, 0, 0, 0, 0, 0, 0, 0])
   }
 
+  @Test
   func testCreateVectorOfStrings() {
     let strs = ["Denmark", "Norway"]
     var b = FlatBufferBuilder(initialSize: 20)
     let o = b.createVector(ofStrings: strs)
     b.finish(offset: o)
     // swiftformat:disable all
-    XCTAssertEqual(
-      b.sizedByteArray,
+    #expect(
+      b.sizedByteArray ==
       [
         4, 0, 0, 0, 2, 0, 0, 0, 20, 0, 0, 0, 4, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0,
         0, 7, 0, 0, 0, 68, 101, 110, 109, 97, 114, 107, 0,
       ])
     // swiftformat:enable all
   }
+  @Test
   func testCreateSharedStringVector() {
     let norway = "Norway"
     let denmark = "Denmark"
@@ -119,8 +125,8 @@ final class FlatBuffersVectors: XCTestCase {
     let end = b.createVector(ofOffsets: v)
     b.finish(offset: end)
     // swiftformat:disable all
-    XCTAssertEqual(
-      b.sizedByteArray,
+    #expect(
+      b.sizedByteArray ==
       [
         4, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 12, 0, 0, 0, 20, 0, 0, 0, 4, 0, 0, 0, 7, 0, 0, 0, 68,
         101, 110, 109, 97, 114, 107, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0,
@@ -128,6 +134,7 @@ final class FlatBuffersVectors: XCTestCase {
     // swiftformat:enable all
   }
 
+  @Test
   func testReadInt32Array() {
     let data: [Int32] = [1, 2, 3, 4, 5]
     var b = FlatBufferBuilder(initialSize: 20)
@@ -136,10 +143,11 @@ final class FlatBuffersVectors: XCTestCase {
     b.finish(offset: end)
     let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray))
     for (index, num) in number.vArrayInt32.enumerated() {
-      XCTAssertEqual(num, data[index])
+      #expect(num == data[index])
     }
   }
 
+  @Test
   func testReadDoubleArray() {
     let data: [Double] = [1, 2, 3, 4, 5]
     var b = FlatBufferBuilder(initialSize: 20)
@@ -148,10 +156,11 @@ final class FlatBuffersVectors: XCTestCase {
     b.finish(offset: end)
     let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray))
     for (index, num) in number.vArrayDouble.enumerated() {
-      XCTAssertEqual(num, data[index])
+      #expect(num == data[index])
     }
   }
 
+  @Test
   func testHasForArray() {
     var builder = FlatBufferBuilder(initialSize: 20)
     let emptyVector = [UInt8]()
@@ -166,14 +175,14 @@ final class FlatBuffersVectors: XCTestCase {
 
     var byteBuffer = ByteBuffer(bytes: builder.sizedByteArray)
     let msg: Swift_Tests_Vectors = getRoot(byteBuffer: &byteBuffer)
-    XCTAssertEqual(msg.none_.isEmpty, true)
-    XCTAssertEqual(msg.empty.isEmpty, true)
-    XCTAssertEqual(msg.empty.count, 0)
-    XCTAssertEqual(msg.array.isEmpty, false)
-    XCTAssertEqual(msg.array.count, 3)
+    #expect(msg.none_.isEmpty == true)
+    #expect(msg.empty.isEmpty == true)
+    #expect(msg.empty.count == 0)
+    #expect(msg.array.isEmpty == false)
+    #expect(msg.array.count == 3)
 
     for i in msg.array.startIndex..<msg.array.endIndex {
-      XCTAssertEqual(msg.array[i], 1 + UInt64(i))
+      #expect(msg.array[i] == 1 + UInt64(i))
     }
 
     let array = msg.withUnsafePointerToArray { ptr, count in
@@ -185,7 +194,7 @@ final class FlatBuffersVectors: XCTestCase {
       return Array(ptr)
     }
 
-    XCTAssertEqual(array, [1, 2, 3])
+    #expect(array == [1, 2, 3])
   }
 }
 

tests/swift/Tests/Flatbuffers/FlatbuffersDoubleTests.swift

@@ -14,14 +14,15 @@
  * limitations under the License.
  */
 
-import XCTest
+import Testing
 
 @testable import FlatBuffers
 
-final class FlatBuffersDoubleTests: XCTestCase {
+struct FlatBuffersDoubleTests {
 
   let country = "Norway"
 
+  @Test
   func testCreateFinish() {
     var b = FlatBufferBuilder(initialSize: 16)
     let countryOff = CountryDouble.createCountry(
@@ -38,9 +39,10 @@ final class FlatBuffersDoubleTests: XCTestCase {
       97, 121, 0, 0,
     ]
     // swiftformat:enable all
-    XCTAssertEqual(b.sizedByteArray, v)
+    #expect(b.sizedByteArray == v)
   }
 
+  @Test
   func testCreateFinishWithPrefix() {
     var b = FlatBufferBuilder(initialSize: 16)
     let countryOff = CountryDouble.createCountry(
@@ -57,7 +59,7 @@ final class FlatBuffersDoubleTests: XCTestCase {
       0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0,
     ]
     // swiftformat:enable all
-    XCTAssertEqual(b.sizedByteArray, v)
+    #expect(b.sizedByteArray == v)
   }
 }
 

tests/swift/Tests/Flatbuffers/FlatbuffersMoreDefaults.swift

@@ -15,11 +15,11 @@
  */
 
 import Foundation
-import XCTest
+import Testing
 
 @testable import FlatBuffers
 
-class FlatBuffersMoreDefaults: XCTestCase {
+struct FlatBuffersMoreDefaults {
 
   func testFlatbuffersObject() {
     var fbb = FlatBufferBuilder()
@@ -27,61 +27,58 @@ class FlatBuffersMoreDefaults: XCTestCase {
     fbb.finish(offset: root)
     var byteBuffer = fbb.sizedBuffer
     let defaults: MoreDefaults = getRoot(byteBuffer: &byteBuffer)
-    XCTAssertEqual(defaults.emptyString, "")
-    XCTAssertEqual(defaults.someString, "some")
-    XCTAssertEqual(defaults.ints.isEmpty, true)
-    XCTAssertEqual(defaults.floats.isEmpty, true)
-    XCTAssertEqual(defaults.bools.isEmpty, true)
-    XCTAssertEqual(defaults.ints.count, 0)
-    XCTAssertEqual(defaults.floats.count, 0)
-    XCTAssertEqual(defaults.abcs.count, 0)
-    XCTAssertEqual(defaults.bools.count, 0)
+    #expect(defaults.emptyString == "")
+    #expect(defaults.someString == "some")
+    #expect(defaults.ints.isEmpty == true)
+    #expect(defaults.floats.isEmpty == true)
+    #expect(defaults.bools.isEmpty == true)
+    #expect(defaults.ints.count == 0)
+    #expect(defaults.floats.count == 0)
+    #expect(defaults.abcs.count == 0)
+    #expect(defaults.bools.count == 0)
   }
 
   func testFlatbuffersObjectAPI() {
     var fbb = FlatBufferBuilder()
     let defaults = MoreDefaultsT()
-    XCTAssertEqual(defaults.emptyString, "")
-    XCTAssertEqual(defaults.someString, "some")
-    XCTAssertEqual(defaults.ints, [])
-    XCTAssertEqual(defaults.floats, [])
-    XCTAssertEqual(defaults.abcs, [])
-    XCTAssertEqual(defaults.bools, [])
+    #expect(defaults.emptyString == "")
+    #expect(defaults.someString == "some")
+    #expect(defaults.ints == [])
+    #expect(defaults.floats == [])
+    #expect(defaults.abcs == [])
+    #expect(defaults.bools == [])
 
     var buffer = defaults.serialize(builder: &fbb, type: MoreDefaults.self)
     let fDefaults: MoreDefaults = getRoot(byteBuffer: &buffer)
-    XCTAssertEqual(fDefaults.emptyString, "")
-    XCTAssertEqual(fDefaults.someString, "some")
-    XCTAssertEqual(fDefaults.ints.isEmpty, true)
-    XCTAssertEqual(fDefaults.floats.isEmpty, true)
-    XCTAssertEqual(fDefaults.ints.count, 0)
-    XCTAssertEqual(fDefaults.floats.count, 0)
-    XCTAssertEqual(fDefaults.abcs.count, 0)
-    XCTAssertEqual(fDefaults.bools.count, 0)
+    #expect(fDefaults.emptyString == "")
+    #expect(fDefaults.someString == "some")
+    #expect(fDefaults.ints.isEmpty == true)
+    #expect(fDefaults.floats.isEmpty == true)
+    #expect(fDefaults.ints.count == 0)
+    #expect(fDefaults.floats.count == 0)
+    #expect(fDefaults.abcs.count == 0)
+    #expect(fDefaults.bools.count == 0)
   }
 
-  func testEncoding() {
+  @Test
+  func testEncoding() throws {
     var fbb = FlatBufferBuilder()
     let root = MoreDefaults.createMoreDefaults(&fbb)
     fbb.finish(offset: root)
     var sizedBuffer = fbb.sizedBuffer
-    do {
-      struct Test: Decodable {
-        var emptyString: String
-        var someString: String
-      }
-      let reader: MoreDefaults = try getCheckedRoot(byteBuffer: &sizedBuffer)
-      let encoder = JSONEncoder()
-      encoder.keyEncodingStrategy = .convertToSnakeCase
-      let data = try encoder.encode(reader)
-      let decoder = JSONDecoder()
-      decoder.keyDecodingStrategy = .convertFromSnakeCase
-      let value = try decoder.decode(Test.self, from: data)
-      XCTAssertEqual(value.someString, "some")
-      XCTAssertEqual(value.emptyString, "")
-    } catch {
-      XCTFail(error.localizedDescription)
+    struct Test: Decodable {
+      var emptyString: String
+      var someString: String
     }
+    let reader: MoreDefaults = try getCheckedRoot(byteBuffer: &sizedBuffer)
+    let encoder = JSONEncoder()
+    encoder.keyEncodingStrategy = .convertToSnakeCase
+    let data = try encoder.encode(reader)
+    let decoder = JSONDecoder()
+    decoder.keyDecodingStrategy = .convertFromSnakeCase
+    let value = try decoder.decode(Test.self, from: data)
+    #expect(value.someString == "some")
+    #expect(value.emptyString == "")
   }
 
 }

tests/swift/Tests/Flatbuffers/FlatbuffersVerifierTests.swift

@@ -14,25 +14,20 @@
  * limitations under the License.
  */
 
-import XCTest
+import Testing
 
 @testable import FlatBuffers
 
-final class FlatbuffersVerifierTests: XCTestCase {
+final class FlatbuffersVerifierTests {
 
-  var buffer: ByteBuffer!
-  var validFlatbuffersObject: ByteBuffer!
-  var invalidFlatbuffersObject: ByteBuffer!
-  var invalidFlatbuffersObject2: ByteBuffer!
-  var invalidFlatbuffersObject3: ByteBuffer!
+  private var buffer: ByteBuffer
+  private var validFlatbuffersObject: ByteBuffer
+  private var invalidFlatbuffersObject: ByteBuffer
+  private var invalidFlatbuffersObject2: ByteBuffer
+  private var invalidFlatbuffersObject3: ByteBuffer
 
-  override func setUp() {
+  init() {
     // swiftformat:disable all
-    let memory = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 1)
-    buffer = ByteBuffer(assumingMemoryBound: memory, capacity: 32)
-    add(buffer: &buffer, v: 4, p: 16)
-    add(buffer: &buffer, v: 4, p: 20)
-
     validFlatbuffersObject = ByteBuffer(bytes: [
       48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0,
       0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0,
@@ -94,186 +89,250 @@ final class FlatbuffersVerifierTests: XCTestCase {
       109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100,
       0x00, 111, 0, 0, 0,
     ])
+
+    let memory = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 1)
+    buffer = ByteBuffer(assumingMemoryBound: memory, capacity: 32)
+
+    add(buffer: &buffer, v: 4, p: 16)
+    add(buffer: &buffer, v: 4, p: 20)
     // swiftformat:enable all
   }
 
-  func testVeriferInitPassing() {
+  @Test
+  func testVeriferInitPassing() throws {
     let memory = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 1)
     var buffer = ByteBuffer(
       assumingMemoryBound: memory,
       capacity: Int(FlatBufferMaxSize) - 1)
-    XCTAssertNoThrow(try Verifier(buffer: &buffer))
+    _ = try Verifier(buffer: &buffer)
   }
 
+  @Test
   func testVeriferInitFailing() {
     let memory = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 1)
     var buffer = ByteBuffer(
       assumingMemoryBound: memory,
       capacity: Int(FlatBufferMaxSize) + 1)
-    XCTAssertThrowsError(try Verifier(buffer: &buffer))
+    #expect(throws: FlatbuffersErrors.exceedsMaxSizeAllowed) {
+      try Verifier(buffer: &buffer)
+    }
   }
 
+  @Test
   func testFailingID() {
     let dutData: [UInt8] = [1, 2, 3, 4, 5, 6, 7]
     var buff = ByteBuffer(bytes: dutData)
-    do {
+    #expect(throws: FlatbuffersErrors.bufferDoesntContainID) {
       let _: Monster = try getCheckedRoot(byteBuffer: &buff, fileId: "ABCD")
-      XCTFail("This should always fail")
-    } catch {
-      XCTAssertEqual(error as? FlatbuffersErrors, .bufferDoesntContainID)
     }
   }
 
-  func testVerifierCheckAlignment() {
+  @Test
+  func testVerifierCheckAlignment() throws {
     let verifier = try! Verifier(buffer: &buffer)
-    do {
+    #expect(throws: FlatbuffersErrors.missAlignedPointer(
+      position: 20,
+      type: "Int"))
+    {
       try verifier.isAligned(position: 20, type: Int.self)
-    } catch {
-      XCTAssertEqual(
-        error as? FlatbuffersErrors,
-        .missAlignedPointer(position: 20, type: "Int"))
     }
-    XCTAssertNoThrow(try verifier.isAligned(position: 16, type: Int.self))
+
+    try verifier.isAligned(position: 16, type: Int.self)
 
     let newVerifer = try! Verifier(buffer: &buffer, checkAlignment: false)
-    XCTAssertNoThrow(try newVerifer.isAligned(position: 16, type: Int.self))
+    try newVerifer.isAligned(position: 16, type: Int.self)
   }
 
-  func testRangeInBuffer() {
+  @Test
+  func testRangeInBuffer() throws {
     var verifier = try! Verifier(buffer: &buffer)
     let size = MemoryLayout<Int64>.size
-    XCTAssertNoThrow(try verifier.rangeInBuffer(position: 24, size: size))
-    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 26, size: size))
-    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 26, size: size))
-    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 30, size: size))
-    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 32, size: size))
-    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 34, size: size))
+    try verifier.rangeInBuffer(position: 24, size: size)
+    #expect(throws: FlatbuffersErrors.outOfBounds(position: 34, end: 32)) {
+      try verifier.rangeInBuffer(position: 26, size: size)
+    }
+    #expect(throws: FlatbuffersErrors.outOfBounds(position: 34, end: 32)) {
+      try verifier.rangeInBuffer(
+        position: 26,
+        size: size)
+    }
+    #expect(throws: FlatbuffersErrors.outOfBounds(position: 38, end: 32)) {
+      try verifier.rangeInBuffer(
+        position: 30,
+        size: size)
+    }
+    #expect(throws: FlatbuffersErrors.outOfBounds(position: 40, end: 32)) {
+      try verifier.rangeInBuffer(
+        position: 32,
+        size: size)
+    }
+    #expect(throws: FlatbuffersErrors.outOfBounds(position: 42, end: 32)) {
+      try verifier.rangeInBuffer(
+        position: 34,
+        size: size)
+    }
 
     verifier = try! Verifier(
       buffer: &buffer,
       options: .init(maxDepth: 0, maxTableCount: 0, maxApparentSize: 4))
-    do {
+
+    #expect(throws: FlatbuffersErrors.apparentSizeTooLarge) {
       try verifier.rangeInBuffer(position: 24, size: size)
-    } catch {
-      XCTAssertEqual(
-        error as! FlatbuffersErrors,
-        .apparentSizeTooLarge)
     }
   }
 
-  func testPositionInBuffer() {
+  @Test
+  func testPositionInBuffer() throws {
     let verifier = try! Verifier(buffer: &buffer)
-    XCTAssertNoThrow(try verifier.inBuffer(position: 0, of: Int64.self))
-    XCTAssertNoThrow(try verifier.inBuffer(position: 24, of: Int64.self))
-    XCTAssertThrowsError(try verifier.inBuffer(position: -9, of: Int64.self))
-    XCTAssertThrowsError(try verifier.inBuffer(position: 25, of: Int64.self))
-    XCTAssertThrowsError(try verifier.inBuffer(position: 26, of: Int32.self))
-    XCTAssertThrowsError(try verifier.inBuffer(position: 26, of: Int64.self))
-    XCTAssertThrowsError(try verifier.inBuffer(position: 30, of: Int64.self))
-    XCTAssertThrowsError(try verifier.inBuffer(position: 32, of: Int64.self))
-    XCTAssertThrowsError(try verifier.inBuffer(position: 34, of: Int64.self))
+    try verifier.inBuffer(position: 0, of: Int64.self)
+    try verifier.inBuffer(position: 24, of: Int64.self)
+
+    #expect(
+      throws: FlatbuffersErrors.missAlignedPointer(
+        position: -9,
+        type: "Int64"))
+    {
+      try verifier.inBuffer(position: -9, of: Int64.self)
+    }
+    #expect(
+      throws: FlatbuffersErrors.missAlignedPointer(
+        position: 25,
+        type: "Int64"))
+    {
+      try verifier.inBuffer(position: 25, of: Int64.self)
+    }
+    #expect(
+      throws: FlatbuffersErrors.missAlignedPointer(
+        position: 26,
+        type: "Int32"))
+    {
+      try verifier.inBuffer(position: 26, of: Int32.self)
+    }
+    #expect(
+      throws: FlatbuffersErrors.missAlignedPointer(
+        position: 26,
+        type: "Int64"))
+    {
+      try verifier.inBuffer(position: 26, of: Int64.self)
+    }
+    #expect(
+      throws: FlatbuffersErrors.missAlignedPointer(
+        position: 30,
+        type: "Int64"))
+    {
+      try verifier.inBuffer(position: 30, of: Int64.self)
+    }
+    #expect(throws: FlatbuffersErrors.outOfBounds(position: 40, end: 32)) {
+      try verifier.inBuffer(
+        position: 32,
+        of: Int64.self)
+    }
+    #expect(
+      throws: FlatbuffersErrors.missAlignedPointer(
+        position: 34,
+        type: "Int64"))
+    {
+      try verifier.inBuffer(position: 34, of: Int64.self)
+    }
   }
 
-  func testVisitTable() {
+  @Test
+  func testVisitTable() throws {
     var verifier = try! Verifier(buffer: &validFlatbuffersObject)
-    XCTAssertNoThrow(try verifier.visitTable(at: 48))
+    _ = try verifier.visitTable(at: 48)
     verifier.reset()
   }
 
-  func testTableVerifier() {
+  @Test
+  func testTableVerifier() throws {
     var verifier = try! Verifier(buffer: &validFlatbuffersObject)
 
     var tableVerifer = try! verifier.visitTable(at: 48)
-    XCTAssertEqual(verifier.depth, 1)
-    XCTAssertEqual(verifier.tableCount, 1)
+    #expect(verifier.depth == 1)
+    #expect(verifier.tableCount == 1)
 
-    XCTAssertNoThrow(
-      try tableVerifer.visit(
-        field: 4,
-        fieldName: "Vec",
-        required: false,
-        type: Vec3.self))
-    XCTAssertNoThrow(
-      try tableVerifer.visit(
-        field: 8,
-        fieldName: "hp",
-        required: false,
-        type: Int16.self))
+    try tableVerifer.visit(
+      field: 4,
+      fieldName: "Vec",
+      required: false,
+      type: Vec3.self)
 
-    XCTAssertNoThrow(
-      try tableVerifer.visit(
-        field: 10,
-        fieldName: "name",
-        required: true,
-        type: ForwardOffset<String>.self))
+    try tableVerifer.visit(
+      field: 8,
+      fieldName: "hp",
+      required: false,
+      type: Int16.self)
 
-    XCTAssertNoThrow(
-      try tableVerifer.visit(
-        field: 14,
-        fieldName: "inventory",
-        required: false,
-        type: ForwardOffset<Vector<UInt8, UInt8>>.self))
+    try tableVerifer.visit(
+      field: 10,
+      fieldName: "name",
+      required: true,
+      type: ForwardOffset<String>.self)
 
-    XCTAssertNoThrow(
-      try tableVerifer.visit(
-        field: 22,
-        fieldName: "test4",
-        required: false,
-        type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>
-          .self))
+    try tableVerifer.visit(
+      field: 14,
+      fieldName: "inventory",
+      required: false,
+      type: ForwardOffset<Vector<UInt8, UInt8>>.self)
 
-    XCTAssertNoThrow(
-      try tableVerifer.visit(
-        field: 24,
-        fieldName: "Vector of strings",
-        required: false,
-        type: ForwardOffset<Vector<ForwardOffset<String>, String>>.self))
+    try tableVerifer.visit(
+      field: 22,
+      fieldName: "test4",
+      required: false,
+      type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>
+        .self)
 
-    do {
+    try tableVerifer.visit(
+      field: 24,
+      fieldName: "Vector of strings",
+      required: false,
+      type: ForwardOffset<Vector<ForwardOffset<String>, String>>.self)
+
+    #expect(throws: FlatbuffersErrors.missAlignedPointer(
+      position: 25,
+      type: "UInt16"))
+    {
       try tableVerifer.visit(
         field: 13,
         fieldName: "notvalid",
         required: false,
         type: Int16.self)
-    } catch {
-      XCTAssertEqual(
-        error as! FlatbuffersErrors,
-        .missAlignedPointer(position: 25, type: "UInt16"))
     }
 
-    do {
-      try tableVerifer.visit(
-        unionKey: 18,
-        unionField: 20,
-        unionKeyName: "testType",
-        fieldName: "test",
-        required: false,
-        completion: { (verifier, key: MyGame_Example_Any_, pos) in
-          switch key {
-          case .none_:
-            break
-          case .monster:
-            try ForwardOffset<MyGame_Example_Monster>.verify(
-              &verifier,
-              at: pos,
-              of: MyGame_Example_Monster.self)
+    try tableVerifer.visit(
+      unionKey: 18,
+      unionField: 20,
+      unionKeyName: "testType",
+      fieldName: "test",
+      required: false,
+      completion: { (verifier, key: MyGame_Example_Any_, pos) in
+        switch key {
+        case .none_:
+          break // NOTE - SWIFT doesnt support none
+        case .monster:
+          try ForwardOffset<MyGame_Example_Monster>.verify(
+            &verifier,
+            at: pos,
+            of: MyGame_Example_Monster.self)
+        case .testsimpletablewithenum:
+          try ForwardOffset<MyGame_Example_TestSimpleTableWithEnum>.verify(
+            &verifier,
+            at: pos,
+            of: MyGame_Example_TestSimpleTableWithEnum.self)
+        case .mygameExample2Monster:
+          try ForwardOffset<MyGame_Example2_Monster>.verify(
+            &verifier,
+            at: pos,
+            of: MyGame_Example2_Monster.self)
+        }
+      })
 
-          case .testsimpletablewithenum:
-            break
-          case .mygameExample2Monster:
-            break
-          }
-        })
-    } catch {
-      XCTAssertEqual(
-        error as! FlatbuffersErrors,
-        .missAlignedPointer(position: 25, type: "UInt16"))
-    }
     tableVerifer.finish()
-    XCTAssertEqual(verifier.depth, 0)
+    #expect(verifier.depth == 0)
   }
 
-  func testVerifyUnionVectors() {
+  @Test
+  func testVerifyUnionVectors() throws {
     // swiftformat:disable all
     var byteBuffer = ByteBuffer(bytes: [
       20, 0, 0, 0, 77, 79, 86, 73, 12, 0, 12, 0, 0, 0, 0, 0, 8, 0, 4, 0, 12, 0, 0, 0, 8, 0, 0, 0,
@@ -281,10 +340,11 @@ final class FlatbuffersVerifierTests: XCTestCase {
       0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0,
     ])
     // swiftformat:enable all
-    XCTAssertNoThrow(try getCheckedRoot(byteBuffer: &byteBuffer) as Movie)
+    _ = try getCheckedRoot(byteBuffer: &byteBuffer) as Movie
   }
 
-  func testErrorWrongFileId() {
+  @Test
+  func testErrorWrongFileId() throws{
     // swiftformat:disable all
     var byteBuffer = ByteBuffer(bytes: [
       20, 0, 0, 0, 77, 79, 86, 73, 12, 0, 12, 0, 0, 0, 0, 0, 8, 0, 4, 0, 12, 0, 0, 0, 8, 0, 0, 0,
@@ -292,12 +352,14 @@ final class FlatbuffersVerifierTests: XCTestCase {
       0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0,
     ])
     // swiftformat:enable all
-    XCTAssertThrowsError(
+    #expect(throws: FlatbuffersErrors.bufferIdDidntMatchPassedId) {
       try getCheckedRoot(
         byteBuffer: &byteBuffer,
-        fileId: "FLEX") as Movie)
+        fileId: "FLEX") as Movie
+    }
   }
 
+  @Test
   func testVerifyPrefixedBuffer() {
     // swiftformat:disable all
     var byteBuffer = ByteBuffer(bytes: [
@@ -306,41 +368,50 @@ final class FlatbuffersVerifierTests: XCTestCase {
       0, 2, 0, 0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0,
     ])
     // swiftformat:enable all
-    XCTAssertThrowsError(
-      try getCheckedPrefixedSizeRoot(byteBuffer: &byteBuffer) as Movie)
+    #expect(throws: FlatbuffersErrors.prefixedSizeNotEqualToBufferSize) {
+      try getCheckedPrefixedSizeRoot(byteBuffer: &byteBuffer) as Movie
+    }
   }
 
-  func testFullVerifier() {
-    XCTAssertNoThrow(
+  @Test
+  func testFullVerifier() throws {
+    _ =
       try getCheckedRoot(
-        byteBuffer: &validFlatbuffersObject) as MyGame_Example_Monster)
+        byteBuffer: &validFlatbuffersObject) as MyGame_Example_Monster
   }
 
-  func testFullVerifierWithFileId() {
-    XCTAssertNoThrow(
-      try getCheckedRoot(
-        byteBuffer: &validFlatbuffersObject,
-        fileId: MyGame_Example_Monster.id) as MyGame_Example_Monster)
+  @Test
+  func testFullVerifierWithFileId() throws {
+    _ = try getCheckedRoot(
+      byteBuffer: &validFlatbuffersObject,
+      fileId: MyGame_Example_Monster.id) as MyGame_Example_Monster
   }
 
+  @Test
   func testInvalidBuffer() {
-    XCTAssertThrowsError(
+    #expect(throws: FlatbuffersErrors.self) {
       try getCheckedRoot(
-        byteBuffer: &invalidFlatbuffersObject) as MyGame_Example_Monster)
+        byteBuffer: &self.invalidFlatbuffersObject) as MyGame_Example_Monster
+    }
   }
 
+  @Test
   func testInvalidBuffer2() {
-    XCTAssertThrowsError(
+    #expect(throws: FlatbuffersErrors.self) {
       try getCheckedRoot(
-        byteBuffer: &invalidFlatbuffersObject2) as MyGame_Example_Monster)
+        byteBuffer: &self.invalidFlatbuffersObject2) as MyGame_Example_Monster
+    }
   }
 
+  @Test
   func testInvalidBuffer3() {
-    XCTAssertThrowsError(
+    #expect(throws: FlatbuffersErrors.self) {
       try getCheckedRoot(
-        byteBuffer: &invalidFlatbuffersObject3) as MyGame_Example_Monster)
+        byteBuffer: &self.invalidFlatbuffersObject3) as MyGame_Example_Monster
+    }
   }
 
+  @Test
   func testValidUnionBuffer() {
     let string = "Awesome \\\\t\t\nstring!"
     var fb = FlatBufferBuilder()
@@ -362,9 +433,14 @@ final class FlatbuffersVerifierTests: XCTestCase {
       charactersVectorOffset: characterVector)
     Movie.finish(&fb, end: end)
     var buf = fb.sizedBuffer
-    XCTAssertNoThrow(try getCheckedRoot(byteBuffer: &buf) as Movie)
+    do {
+      _ = try getCheckedRoot(byteBuffer: &buf) as Movie
+    } catch {
+      Issue.record(error)
+    }
   }
 
+  @Test
   func testNestedTables() throws {
     var builder = FlatBufferBuilder()
     let name = builder.create(string: "Monster")
@@ -383,22 +459,22 @@ final class FlatbuffersVerifierTests: XCTestCase {
     var verifier = try! Verifier(buffer: &sizedBuffer)
     var tableVerifer = try! verifier.visitTable(
       at: try getOffset(at: 0, within: verifier))
-    XCTAssertEqual(verifier.depth, 1)
-    XCTAssertEqual(verifier.tableCount, 1)
+    #expect(verifier.depth == 1)
+    #expect(verifier.tableCount == 1)
 
     let position = try tableVerifer.dereference(28)!
 
     var nestedTable = try verifier.visitTable(
       at: try getOffset(at: position, within: verifier))
 
-    XCTAssertEqual(verifier.depth, 2)
-    XCTAssertEqual(verifier.tableCount, 2)
+    #expect(verifier.depth == 2)
+    #expect(verifier.tableCount == 2)
     nestedTable.finish()
-    XCTAssertEqual(verifier.depth, 1)
-    XCTAssertEqual(verifier.tableCount, 2)
+    #expect(verifier.depth == 1)
+    #expect(verifier.tableCount == 2)
     tableVerifer.finish()
-    XCTAssertEqual(verifier.depth, 0)
-    XCTAssertEqual(verifier.tableCount, 2)
+    #expect(verifier.depth == 0)
+    #expect(verifier.tableCount == 2)
   }
 
   func add(buffer: inout ByteBuffer, v: Int32, p: Int) {

tests/swift/Tests/Flatbuffers/MutatingBool_generated.swift

@@ -74,7 +74,7 @@ public struct Property_Mutable: FlatBufferStruct, FlatbuffersVectorInitializable
   }
 }
 
-public struct TestMutatingBool: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct TestMutatingBool: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/Tests/Flatbuffers/arrays_test_generated.swift

@@ -398,7 +398,7 @@ public struct MyGame_Example_LargeArrayStruct_Mutable: FlatBufferStruct, Flatbuf
 }
 
 @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
-public struct MyGame_Example_ArrayTable: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example_ArrayTable: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/Tests/Flatbuffers/empty_vtable_generated.swift

@@ -8,7 +8,7 @@ import Common
 
 import FlatBuffers
 
-public struct DataModel_A: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct DataModel_A: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/Tests/Flatbuffers/monster_test.grpc.swift

@@ -5,206 +5,568 @@
 // swiftlint:disable all
 // swiftformat:disable all
 
-#if !os(Windows)
-import Foundation
-import GRPC
-import NIO
-import NIOHTTP1
+#if !os(Windows) && compiler(>=6.0)
 import FlatBuffers
+import Foundation
+import GRPCCore
+import GRPCNIOTransportCore
 
-public protocol GRPCFlatBufPayload: GRPCPayload, FlatBufferGRPCMessage {}
-public extension GRPCFlatBufPayload {
-  init(serializedByteBuffer: inout NIO.ByteBuffer) throws {
-    self.init(byteBuffer: FlatBuffers.ByteBuffer(contiguousBytes: serializedByteBuffer.readableBytesView, count: serializedByteBuffer.readableBytes))
-  }
-  func serialize(into buffer: inout NIO.ByteBuffer) throws {
-    withUnsafeReadableBytes { buffer.writeBytes($0) }
-  }
-}
-extension Message: GRPCFlatBufPayload {}
 
-/// Usage: instantiate MyGame_Example_MonsterStorageServiceClient, then call methods of this protocol to make API calls.
-public protocol MyGame_Example_MonsterStorageClientProtocol: GRPCClient {
-
-  var serviceName: String { get }
-
-  var interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol? { get }
-
-  func Store(
-    _ request: Message<MyGame_Example_Monster>
-    , callOptions: CallOptions?
-  ) -> UnaryCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>
-
-  func Retrieve(
-    _ request: Message<MyGame_Example_Stat>
-    , callOptions: CallOptions?,
-    handler: @escaping (Message<MyGame_Example_Monster>) -> Void
-  ) -> ServerStreamingCall<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>
-
-  func GetMaxHitPoint(
-    callOptions: CallOptions?
-  ) -> ClientStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>
-
-  func GetMinMaxHitPoints(
-    callOptions: CallOptions?,
-    handler: @escaping (Message<MyGame_Example_Stat> ) -> Void
-  ) -> BidirectionalStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>
-
-}
-
-extension MyGame_Example_MonsterStorageClientProtocol {
-
-  public var serviceName: String { "MyGame.Example.MonsterStorage" }
-
-  public func Store(
-    _ request: Message<MyGame_Example_Monster>
-    , callOptions: CallOptions? = nil
-  ) -> UnaryCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>> {
-    return self.makeUnaryCall(
-      path: "/MyGame.Example.MonsterStorage/Store",
-      request: request,
-      callOptions: callOptions ?? self.defaultCallOptions,
-      interceptors: self.interceptors?.makeStoreInterceptors() ?? []
-    )
-  }
-
-  public func Retrieve(
-    _ request: Message<MyGame_Example_Stat>
-    , callOptions: CallOptions? = nil,
-    handler: @escaping (Message<MyGame_Example_Monster>) -> Void
-  ) -> ServerStreamingCall<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>> {
-    return self.makeServerStreamingCall(
-      path: "/MyGame.Example.MonsterStorage/Retrieve",
-      request: request,
-      callOptions: callOptions ?? self.defaultCallOptions,
-      interceptors: self.interceptors?.makeRetrieveInterceptors() ?? [],
-      handler: handler
-    )
-  }
-
-  public func GetMaxHitPoint(
-    callOptions: CallOptions? = nil
-  ) -> ClientStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>> {
-    return self.makeClientStreamingCall(
-      path: "/MyGame.Example.MonsterStorage/GetMaxHitPoint",
-      callOptions: callOptions ?? self.defaultCallOptions,
-      interceptors: self.interceptors?.makeGetMaxHitPointInterceptors() ?? []
-    )
-  }
-
-  public func GetMinMaxHitPoints(
-    callOptions: CallOptions? = nil,
-    handler: @escaping (Message<MyGame_Example_Stat> ) -> Void
-  ) -> BidirectionalStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>> {
-    return self.makeBidirectionalStreamingCall(
-      path: "/MyGame.Example.MonsterStorage/GetMinMaxHitPoints",
-      callOptions: callOptions ?? self.defaultCallOptions,
-      interceptors: self.interceptors?.makeGetMinMaxHitPointsInterceptors() ?? [],
-      handler: handler
-    )
-  }
-}
-
-public protocol MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol {
-  /// - Returns: Interceptors to use when invoking 'Store'.
-  func makeStoreInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
-
-  /// - Returns: Interceptors to use when invoking 'Retrieve'.
-  func makeRetrieveInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>]
-
-  /// - Returns: Interceptors to use when invoking 'GetMaxHitPoint'.
-  func makeGetMaxHitPointInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
-
-  /// - Returns: Interceptors to use when invoking 'GetMinMaxHitPoints'.
-  func makeGetMinMaxHitPointsInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
-
-}
-
-public final class MyGame_Example_MonsterStorageServiceClient: MyGame_Example_MonsterStorageClientProtocol {
-  public let channel: GRPCChannel
-  public var defaultCallOptions: CallOptions
-  public var interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol?
-
-  public init(
-    channel: GRPCChannel,
-    defaultCallOptions: CallOptions = CallOptions(),
-    interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol? = nil
-  ) {
-    self.channel = channel
-    self.defaultCallOptions = defaultCallOptions
-    self.interceptors = interceptors
-  }
-}
-
-public protocol MyGame_Example_MonsterStorageProvider: CallHandlerProvider {
-  var interceptors: MyGame_Example_MonsterStorageServerInterceptorFactoryProtocol? { get }
-  func Store(request: Message<MyGame_Example_Monster>, context: StatusOnlyCallContext) -> EventLoopFuture<Message<MyGame_Example_Stat>>
-  func Retrieve(request: Message<MyGame_Example_Stat>, context: StreamingResponseCallContext<Message<MyGame_Example_Monster>>) -> EventLoopFuture<GRPCStatus>
-  func GetMaxHitPoint(context: UnaryResponseCallContext<Message<MyGame_Example_Stat>>) -> EventLoopFuture<(StreamEvent<Message<MyGame_Example_Monster>>) -> Void>
-  func GetMinMaxHitPoints(context: StreamingResponseCallContext<Message<MyGame_Example_Stat>>) -> EventLoopFuture<(StreamEvent<Message<MyGame_Example_Monster>>) -> Void>
-}
-
-public extension MyGame_Example_MonsterStorageProvider {
-
-  var serviceName: Substring { return "MyGame.Example.MonsterStorage" }
-
-  func handle(method name: Substring, context: CallHandlerContext) -> GRPCServerHandlerProtocol? {
-    switch name {
-    case "Store":
-    return UnaryServerHandler(
-      context: context,
-      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
-      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
-      interceptors: self.interceptors?.makeStoreInterceptors() ?? [],
-      userFunction: self.Store(request:context:))
-
-    case "Retrieve":
-    return ServerStreamingServerHandler(
-      context: context,
-      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Stat>>(),
-      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Monster>>(),
-      interceptors: self.interceptors?.makeRetrieveInterceptors() ?? [],
-      userFunction: self.Retrieve(request:context:))
-
-    case "GetMaxHitPoint":
-    return ClientStreamingServerHandler(
-      context: context,
-      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
-      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
-      interceptors: self.interceptors?.makeGetMaxHitPointInterceptors() ?? [],
-      observerFactory: self.GetMaxHitPoint(context:))
-
-    case "GetMinMaxHitPoints":
-    return BidirectionalStreamingServerHandler(
-      context: context,
-      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
-      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
-      interceptors: self.interceptors?.makeGetMinMaxHitPointsInterceptors() ?? [],
-      observerFactory: self.GetMinMaxHitPoints(context:))
-
-    default: return nil;
+/// Usage: instantiate MyGame.Example.MonsterStorageServiceClient, then call methods of this protocol to make API calls.
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension FlatBuffersMessageSerializer: MessageSerializer {
+  public func serialize<Bytes>(_ message: Message) throws -> Bytes where Bytes : GRPCCore.GRPCContiguousBytes {
+    do {
+      return try self.serialize(message: message) { GRPCNIOTransportBytes($0) } as! Bytes
+    } catch let error {
+      throw RPCError(
+        code: .invalidArgument,
+        message: "Can't serialize message",
+        cause: error
+      )
     }
   }
-
 }
 
-public protocol MyGame_Example_MonsterStorageServerInterceptorFactoryProtocol {
-  /// - Returns: Interceptors to use when handling 'Store'.
-  ///   Defaults to calling `self.makeInterceptors()`.
-  func makeStoreInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
-
-  /// - Returns: Interceptors to use when handling 'Retrieve'.
-  ///   Defaults to calling `self.makeInterceptors()`.
-  func makeRetrieveInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>]
-
-  /// - Returns: Interceptors to use when handling 'GetMaxHitPoint'.
-  ///   Defaults to calling `self.makeInterceptors()`.
-  func makeGetMaxHitPointInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
-
-  /// - Returns: Interceptors to use when handling 'GetMinMaxHitPoints'.
-  ///   Defaults to calling `self.makeInterceptors()`.
-  func makeGetMinMaxHitPointsInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
-
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension FlatBuffersMessageDeserializer: MessageDeserializer {
+  public func deserialize<Bytes>(_ serializedMessageBytes: Bytes) throws -> Message where Bytes : GRPCCore.GRPCContiguousBytes {
+    do {
+      return try serializedMessageBytes.withUnsafeBytes {
+        try self.deserialize(pointer: $0)
+      }
+    } catch let error {
+      throw RPCError(
+        code: .invalidArgument,
+        message: "Can't Decode message of type \(Message.self)",
+        cause: error
+      )
+    }
+  }
 }
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+public enum MyGame_Example_MonsterStorage: Sendable {
+  public static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage")
+  public enum Method: Sendable {
+    public enum Store: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = MyGame_Example_Stat
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage"),
+        method: "Store"
+      )
+    }
+    public enum Retrieve: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = MyGame_Example_Monster
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage"),
+        method: "Retrieve"
+      )
+    }
+    public enum GetMaxHitPoint: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = MyGame_Example_Stat
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage"),
+        method: "GetMaxHitPoint"
+      )
+    }
+    public enum GetMinMaxHitPoints: Sendable {
+      public typealias Input = FlatBufferBuilder
+      public typealias Output = MyGame_Example_Stat
+      public static let descriptor = GRPCCore.MethodDescriptor(
+        service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage"),
+        method: "GetMinMaxHitPoints"
+      )
+    }
+    public static let descriptors: [GRPCCore.MethodDescriptor] = [
+      Store.descriptor,
+      Retrieve.descriptor,
+      GetMaxHitPoint.descriptor,
+      GetMinMaxHitPoints.descriptor,
+    ]
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension GRPCCore.ServiceDescriptor {
+  public static let MyGame_Example_MonsterStorage = GRPCCore.ServiceDescriptor(fullyQualifiedService: "MyGame.Example.MonsterStorage")
+}
+
+// MARK: MyGame.Example.MonsterStorage Server
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension MyGame_Example_MonsterStorage {
+  public protocol StreamingServiceProtocol: GRPCCore.RegistrableRPCService {
+    func Store(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>>
+    
+    func Retrieve(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Monster>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Monster>>
+    
+    func GetMaxHitPoint(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>>
+    
+    func GetMinMaxHitPoints(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>>
+    
+  }
+  
+  public protocol ServiceProtocol: MyGame_Example_MonsterStorage.StreamingServiceProtocol {
+    func Store(
+      request: GRPCCore.ServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>>
+    
+    func Retrieve(
+      request: GRPCCore.ServerRequest<GRPCMessage<MyGame_Example_Monster>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Monster>>
+    
+    func GetMaxHitPoint(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>>
+    
+    func GetMinMaxHitPoints(
+      request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>>
+    
+  }
+  
+  public protocol SimpleServiceProtocol: MyGame_Example_MonsterStorage.ServiceProtocol {
+    func Store(
+      request: GRPCMessage<MyGame_Example_Stat>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCMessage<MyGame_Example_Stat>
+    
+    func Retrieve(
+      request: GRPCMessage<MyGame_Example_Monster>,
+      response: GRPCCore.RPCWriter<GRPCMessage<MyGame_Example_Monster>>,
+      context: GRPCCore.ServerContext
+    ) async throws
+    
+    func GetMaxHitPoint(
+      request: GRPCCore.RPCAsyncSequence<GRPCMessage<MyGame_Example_Stat>, any Swift.Error>,
+      context: GRPCCore.ServerContext
+    ) async throws -> GRPCMessage<MyGame_Example_Stat>
+    
+    func GetMinMaxHitPoints(
+      request: GRPCCore.RPCAsyncSequence<GRPCMessage<MyGame_Example_Stat>, any Swift.Error>,
+      response: GRPCCore.RPCWriter<GRPCMessage<MyGame_Example_Stat>>,
+      context: GRPCCore.ServerContext
+    ) async throws
+    
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension MyGame_Example_MonsterStorage.StreamingServiceProtocol {
+  public func registerMethods<Transport>(with router: inout GRPCCore.RPCRouter<Transport>) where Transport: GRPCCore.ServerTransport {
+    router.registerHandler(
+      forMethod: MyGame_Example_MonsterStorage.Method.Store.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
+      handler: { request, context in
+        try await self.Store(
+          request: request,
+          context: context
+        )
+      }
+    )
+    router.registerHandler(
+      forMethod: MyGame_Example_MonsterStorage.Method.Retrieve.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Monster>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Monster>>(),
+      handler: { request, context in
+        try await self.Retrieve(
+          request: request,
+          context: context
+        )
+      }
+    )
+    router.registerHandler(
+      forMethod: MyGame_Example_MonsterStorage.Method.GetMaxHitPoint.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
+      handler: { request, context in
+        try await self.GetMaxHitPoint(
+          request: request,
+          context: context
+        )
+      }
+    )
+    router.registerHandler(
+      forMethod: MyGame_Example_MonsterStorage.Method.GetMinMaxHitPoints.descriptor,
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
+      handler: { request, context in
+        try await self.GetMinMaxHitPoints(
+          request: request,
+          context: context
+        )
+      }
+    )
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension MyGame_Example_MonsterStorage.ServiceProtocol {
+  public func Store(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>> {
+    let response = try await self.Store(
+      request: GRPCCore.ServerRequest(stream: request),
+      context: context
+    )
+    return GRPCCore.StreamingServerResponse(single: response)
+  }
+  public func Retrieve(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Monster>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Monster>> {
+    let response = try await self.Retrieve(
+      request: GRPCCore.ServerRequest(stream: request),
+      context: context
+    )
+    return response
+  }
+  public func GetMaxHitPoint(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>> {
+    let response = try await self.GetMaxHitPoint(
+      request: request,
+      context: context
+    )
+    return GRPCCore.StreamingServerResponse(single: response)
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension MyGame_Example_MonsterStorage.SimpleServiceProtocol {
+  public func Store(
+    request: GRPCCore.ServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>> {
+    return GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>>(
+      message: try await self.Store(
+        request: request.message,
+        context: context
+      ),
+      metadata: [:]
+    )
+  }
+  public func Retrieve(
+    request: GRPCCore.ServerRequest<GRPCMessage<MyGame_Example_Monster>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Monster>> {
+    return GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Monster>>(
+      metadata: [:],
+      producer: { writer in
+        try await self.Retrieve(
+          request: request.message,
+          response: writer,
+          context: context
+        )
+        return [:]
+      }
+    )
+  }
+  public func GetMaxHitPoint(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>> {
+    return GRPCCore.ServerResponse<GRPCMessage<MyGame_Example_Stat>>(
+      message: try await self.GetMaxHitPoint(
+        request: request.messages,
+        context: context
+      ),
+      metadata: [:]
+    )
+  }
+  public func GetMinMaxHitPoints(
+    request: GRPCCore.StreamingServerRequest<GRPCMessage<MyGame_Example_Stat>>,
+    context: GRPCCore.ServerContext
+  ) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>> {
+    return GRPCCore.StreamingServerResponse<GRPCMessage<MyGame_Example_Stat>>(
+      metadata: [:],
+      producer: { writer in
+        try await self.GetMinMaxHitPoints(
+          request: request.messages,
+          response: writer,
+          context: context
+        )
+        return [:]
+      }
+    )
+  }
+}
+
+
+// MARK: MyGame.Example.MonsterStorage Client
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension MyGame_Example_MonsterStorage {
+  public protocol ClientProtocol: Sendable {
+    func Store<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Stat>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+    func Retrieve<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Monster>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Monster>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Monster>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Monster>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+    func GetMaxHitPoint<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+    func GetMinMaxHitPoints<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
+      options: GRPCCore.CallOptions,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable
+    
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension MyGame_Example_MonsterStorage {
+  public struct Client<Transport>: ClientProtocol where Transport: GRPCCore.ClientTransport {
+    private let client: GRPCCore.GRPCClient<Transport>
+    
+    public init(wrapping client: GRPCCore.GRPCClient<Transport>) {
+      self.client = client
+    }
+    
+    public func Store<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Stat>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { response in try response.message }
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.unary(
+        request: request,
+        descriptor: MyGame_Example_MonsterStorage.Method.Store.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+    public func Retrieve<Result>(
+      request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Monster>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Monster>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Monster>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Monster>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.serverStreaming(
+        request: request,
+        descriptor: MyGame_Example_MonsterStorage.Method.Retrieve.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+    public func GetMaxHitPoint<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { response in try response.message }
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.clientStreaming(
+        request: request,
+        descriptor: MyGame_Example_MonsterStorage.Method.GetMaxHitPoint.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+    public func GetMinMaxHitPoints<Result>(
+      request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
+      serializer: some GRPCCore.MessageSerializer<GRPCMessage<MyGame_Example_Stat>>,
+      deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<MyGame_Example_Stat>>,
+      options: GRPCCore.CallOptions = .defaults,
+      onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
+    ) async throws -> Result where Result: Sendable {
+      try await self.client.bidirectionalStreaming(
+        request: request,
+        descriptor: MyGame_Example_MonsterStorage.Method.GetMinMaxHitPoints.descriptor,
+        serializer: serializer,
+        deserializer: deserializer,
+        options: options,
+        onResponse: handleResponse
+      )
+    }
+    
+  }
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension MyGame_Example_MonsterStorage.ClientProtocol {
+  public func Store<Result>(
+    request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Stat>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { response in try response.message }
+  ) async throws -> Result where Result: Sendable {
+    try await self.Store(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Retrieve<Result>(
+    request: GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Monster>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Monster>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    try await self.Retrieve(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Monster>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Monster>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func GetMaxHitPoint<Result>(
+    request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { response in try response.message }
+  ) async throws -> Result where Result: Sendable {
+    try await self.GetMaxHitPoint(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func GetMinMaxHitPoints<Result>(
+    request: GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>,
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    try await self.GetMinMaxHitPoints(
+      request: request,
+      serializer: FlatBuffersMessageSerializer<GRPCMessage<MyGame_Example_Stat>>(),
+      deserializer: FlatBuffersMessageDeserializer<GRPCMessage<MyGame_Example_Stat>>(),
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+}
+
+@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+extension MyGame_Example_MonsterStorage.ClientProtocol {
+  public func Store<Result>(
+    _ message: GRPCMessage<MyGame_Example_Stat>,
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { try $0.message }
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Stat>>(
+      message: message,
+      metadata: metadata
+    )
+    return try await self.Store(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func Retrieve<Result>(
+    _ message: GRPCMessage<MyGame_Example_Monster>,
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Monster>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.ClientRequest<GRPCMessage<MyGame_Example_Monster>>(
+      message: message,
+      metadata: metadata
+    )
+    return try await self.Retrieve(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func GetMaxHitPoint<Result>(
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    requestProducer producer: @Sendable @escaping (GRPCCore.RPCWriter<GRPCMessage<MyGame_Example_Stat>>) async throws -> Void,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result = { try $0.message }
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>(
+      metadata: metadata,
+      producer: producer
+    )
+    return try await self.GetMaxHitPoint(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+  public func GetMinMaxHitPoints<Result>(
+    metadata: GRPCCore.Metadata = [:],
+    options: GRPCCore.CallOptions = .defaults,
+    requestProducer producer: @Sendable @escaping (GRPCCore.RPCWriter<GRPCMessage<MyGame_Example_Stat>>) async throws -> Void,
+    onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<MyGame_Example_Stat>>) async throws -> Result
+  ) async throws -> Result where Result: Sendable {
+    let request = GRPCCore.StreamingClientRequest<GRPCMessage<MyGame_Example_Stat>>(
+      metadata: metadata,
+      producer: producer
+    )
+    return try await self.GetMinMaxHitPoints(
+      request: request,
+      options: options,
+      onResponse: handleResponse
+    )
+  }
+  
+}
+
 #endif
 

tests/swift/Tests/Flatbuffers/monster_test_generated.swift

@@ -662,7 +662,7 @@ public struct MyGame_Example_StructOfStructsOfStructs_Mutable: FlatBufferStruct,
   }
 }
 
-public struct MyGame_InParentNamespace: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_InParentNamespace: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -712,7 +712,7 @@ public class MyGame_InParentNamespaceT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_InParentNamespace.self) }
 
 }
-public struct MyGame_Example2_Monster: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example2_Monster: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -762,7 +762,7 @@ public class MyGame_Example2_MonsterT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example2_Monster.self) }
 
 }
-internal struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+internal struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   internal var __buffer: ByteBuffer! { return _accessor.bb }
@@ -840,7 +840,7 @@ internal class MyGame_Example_TestSimpleTableWithEnumT: NativeObject {
   internal func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TestSimpleTableWithEnum.self) }
 
 }
-public struct MyGame_Example_Stat: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example_Stat: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -976,7 +976,7 @@ public class MyGame_Example_StatT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Stat.self) }
 
 }
-public struct MyGame_Example_Referrable: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example_Referrable: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -1079,7 +1079,7 @@ public class MyGame_Example_ReferrableT: NativeObject {
 
 }
 ///  an example documentation comment: "monster object"
-public struct MyGame_Example_Monster: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example_Monster: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -2213,7 +2213,7 @@ public class MyGame_Example_MonsterT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }
 
 }
-public struct MyGame_Example_TypeAliases: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example_TypeAliases: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/Tests/Flatbuffers/more_defaults_generated.swift

@@ -31,7 +31,7 @@ extension ABC: Encodable {
   }
 }
 
-public struct MoreDefaults: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MoreDefaults: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/Tests/Flatbuffers/nan_inf_test_generated.swift

@@ -8,7 +8,7 @@ import Common
 
 import FlatBuffers
 
-public struct Swift_Tests_NanInfTable: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {
+public struct Swift_Tests_NanInfTable: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/Tests/Flatbuffers/optional_scalars_generated.swift

@@ -31,7 +31,7 @@ extension optional_scalars_OptionalByte: Encodable {
   }
 }
 
-public struct optional_scalars_ScalarStuff: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {
+public struct optional_scalars_ScalarStuff: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/Tests/Flatbuffers/union_vector_generated.swift

@@ -320,7 +320,7 @@ public struct FallingTub_Mutable: FlatBufferStruct, FlatbuffersVectorInitializab
   }
 }
 
-public struct Attacker: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct Attacker: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -398,7 +398,7 @@ public class AttackerT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: Attacker.self) }
 
 }
-public struct HandFan: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct HandFan: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -476,7 +476,7 @@ public class HandFanT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: HandFan.self) }
 
 }
-public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct Movie: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/Tests/Flatbuffers/vector_has_test_generated.swift

@@ -8,7 +8,7 @@ import Common
 
 import FlatBuffers
 
-public struct Swift_Tests_Vectors: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {
+public struct Swift_Tests_Vectors: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/Tests/Flexbuffers/FlexBuffersJSONTests.swift

@@ -16,17 +16,19 @@
 
 import Common
 import FlexBuffers
-import XCTest
+import Foundation
+import Testing
 
-final class FlexBuffersJSONTests: XCTestCase {
+struct FlexBuffersJSONTests {
+  @Test
   func testEncodingJSON() throws {
     let buf: ByteBuffer = createProperBuffer().sizedByteBuffer
     let reference = try getRoot(buffer: buf)!
 
     let json = reference.jsonString()
     // swiftformat:disable all
-    XCTAssertEqual(
-      json,
+    #expect(
+      json ==
       "{\"bar\": [1, 2, 3], \"bar3\": [1, 2, 3], \"bool\": true, \"bools\": [true, false, true, false], \"foo\": 100.0, \"mymap\": {\"foo\": \"Fred\"}, \"vec\": [-100, \"Fred\", 4.0, \"M\", false, 4.0]}"
     )
     // swiftformat:enable all
@@ -37,15 +39,15 @@ final class FlexBuffersJSONTests: XCTestCase {
         with: data,
         options: []) as! [String: Any]
 
-    XCTAssertEqual(decodedData["bar"] as! [Int], [1, 2, 3])
-    XCTAssertEqual(decodedData["bar3"] as! [Int], [1, 2, 3])
+    #expect(decodedData["bar"] as! [Int] == [1, 2, 3])
+    #expect(decodedData["bar3"] as! [Int] == [1, 2, 3])
 
     let vec: [Any] = decodedData["vec"] as! [Any]
-    XCTAssertEqual(vec[0] as! Int, -100)
-    XCTAssertEqual(vec[1] as! String, "Fred")
-    XCTAssertEqual(vec[2] as! Double, 4.0)
-    XCTAssertEqual(vec[3] as! String, "M")
-    XCTAssertEqual(vec[4] as! Bool, false)
-    XCTAssertEqual(vec[5] as! Double, 4.0)
+    #expect(vec[0] as! Int == -100)
+    #expect(vec[1] as! String == "Fred")
+    #expect(vec[2] as! Double == 4.0)
+    #expect(vec[3] as! String == "M")
+    #expect(vec[4] as! Bool == false)
+    #expect(vec[5] as! Double == 4.0)
   }
 }

tests/swift/Tests/Flexbuffers/FlexBuffersReaderTests.swift

@@ -15,22 +15,26 @@
  */
 
 import Common
-import XCTest
+import Foundation
+import Testing
 
 @testable import FlexBuffers
 
-final class FlexBuffersReaderTests: XCTestCase {
+struct FlexBuffersReaderTests {
 
+  @Test
   func testReadingProperBuffer() throws {
     let buf: ByteBuffer = createProperBuffer().byteBuffer
     try validate(buffer: buf)
   }
 
+  @Test
   func testReadingSizedBuffer() throws {
     let buf: ByteBuffer = createSizedBuffer()
     try validate(buffer: buf)
   }
 
+  @Test(.bug("https://github.com/google/flatbuffers/issues/8642"))
   func testReset() throws {
     var fbx = FlexBuffersWriter(
       initialSize: 8,
@@ -38,87 +42,87 @@ final class FlexBuffersReaderTests: XCTestCase {
     write(fbx: &fbx)
 
     try validate(buffer: ByteBuffer(data: fbx.data))
-    XCTAssertEqual(fbx.capacity, 512)
+    #expect(fbx.capacity == 512)
     fbx.reset()
-    XCTAssertEqual(fbx.writerIndex, 0)
-    XCTAssertEqual(fbx.capacity, 8)
+    #expect(fbx.writerIndex == 0)
+    #expect(fbx.capacity == 8)
 
     write(fbx: &fbx)
     try validate(buffer: ByteBuffer(data: fbx.data))
     fbx.reset(keepingCapacity: true)
-    XCTAssertEqual(fbx.writerIndex, 0)
-    XCTAssertEqual(fbx.capacity, 512)
+    #expect(fbx.writerIndex == 0)
+    #expect(fbx.capacity == 512)
 
     write(fbx: &fbx)
     try validate(buffer: ByteBuffer(data: fbx.data))
-    XCTAssertEqual(fbx.capacity, 512)
+    #expect(fbx.capacity == 512)
   }
 
   private func validate(buffer buf: ByteBuffer) throws {
     let reference = try getRoot(buffer: buf)!
-    XCTAssertEqual(reference.type, .map)
+    #expect(reference.type == .map)
     let map = reference.map!
-    XCTAssertEqual(map.count, 7)
+    #expect(map.count == 7)
     let vecRef = map["vec"]!
-    XCTAssertEqual(vecRef.type, .vector)
+    #expect(vecRef.type == .vector)
     let vec = vecRef.vector!
-    XCTAssertEqual(vec.count, 6)
-    XCTAssertEqual(vec[0]?.type, .int)
-    XCTAssertEqual(vec[0]?.int, -100)
-    XCTAssertEqual(vec[1]?.type, .string)
-    XCTAssertEqual(vec[1]?.cString, "Fred")
-    XCTAssertNil(vec[1]?.int)
-    XCTAssertEqual(vec[2]?.double, 4.0)
-    XCTAssertTrue(vec[3]?.type == .blob)
+    #expect(vec.count == 6)
+    #expect(vec[0]?.type == .int)
+    #expect(vec[0]?.int == -100)
+    #expect(vec[1]?.type == .string)
+    #expect(vec[1]?.cString == "Fred")
+    #expect(vec[1]?.int == nil)
+    #expect(vec[2]?.double == 4.0)
+    #expect(vec[3]?.type == .blob)
 
     let blob = vec[3]!.blob { pointer in
       Array(pointer)
     }
 
-    XCTAssertEqual(blob?.count, 1)
-    XCTAssertEqual(blob?[0], 77)
-    XCTAssertEqual(vec[4]?.type, .bool)
-    XCTAssertEqual(vec[4]?.bool, false)
-    XCTAssertEqual(vec[5]?.double, 4.0)  // Shared with vec[2]
+    #expect(blob?.count == 1)
+    #expect(blob?[0] == 77)
+    #expect(vec[4]?.type == .bool)
+    #expect(vec[4]?.bool == false)
+    #expect(vec[5]?.double == 4.0)  // Shared with vec[2]
 
     let barVec = map["bar"]!.typedVector!
-    XCTAssertEqual(barVec.count, 3)
-    XCTAssertEqual(barVec[2]?.int, 3)
-    XCTAssertEqual(barVec[2]?.asInt(), UInt8(3))
+    #expect(barVec.count == 3)
+    #expect(barVec[2]?.int == 3)
+    #expect(barVec[2]?.asInt() == UInt8(3))
 
     let fixedVec = map["bar3"]!.fixedTypedVector!
-    XCTAssertEqual(fixedVec.count, 3)
-    XCTAssertEqual(fixedVec[2]?.int, 3)
-    XCTAssertEqual(fixedVec[2]?.asInt(), UInt8(3))
-    XCTAssertEqual(map["bool"]?.bool, true)
+    #expect(fixedVec.count == 3)
+    #expect(fixedVec[2]?.int == 3)
+    #expect(fixedVec[2]?.asInt() == UInt8(3))
+    #expect(map["bool"]?.bool == true)
 
     let boolsVector = map["bools"]!.typedVector!
-    XCTAssertEqual(boolsVector.type, .bool)
-    XCTAssertEqual(boolsVector[0]?.bool, true)
-    XCTAssertEqual(boolsVector[1]?.bool, false)
+    #expect(boolsVector.type == .bool)
+    #expect(boolsVector[0]?.bool == true)
+    #expect(boolsVector[1]?.bool == false)
 
     let bools = [true, false, true, false]
     boolsVector.withUnsafeRawBufferPointer { buff in
       for i in 0..<boolsVector.count {
-        XCTAssertEqual(buff.load(fromByteOffset: i, as: Bool.self), bools[i])
+        #expect(buff.load(fromByteOffset: i, as: Bool.self) == bools[i])
       }
     }
-    XCTAssertEqual(map["foo"]?.double, 100)
-    XCTAssertNil(map["unknown"])
+    #expect(map["foo"]?.double == 100)
+    #expect(map["unknown"] == nil)
     let mymap = map["mymap"]?.map
 
     // Check if both addresses used are the same for keys and strings
-    XCTAssertEqual(mymap?.keys[0]?.cString, map.keys[4]?.cString)
+    #expect(mymap?.keys[0]?.cString == map.keys[4]?.cString)
     map.keys[4]?.withUnsafeRawPointer { pointer in
       mymap?.keys[0]?.withUnsafeRawPointer { mymapPointer in
-        XCTAssertEqual(pointer, mymapPointer)
+        #expect(pointer == mymapPointer)
       }
     }
 
-    XCTAssertEqual(mymap?.values[0]?.cString, vec[1]?.cString)
+    #expect(mymap?.values[0]?.cString == vec[1]?.cString)
     vec[1]?.withUnsafeRawPointer { pointer in
       mymap?.values[0]?.withUnsafeRawPointer { mymapPointer in
-        XCTAssertEqual(pointer, mymapPointer)
+        #expect(pointer == mymapPointer)
       }
     }
   }
@@ -127,7 +131,7 @@ final class FlexBuffersReaderTests: XCTestCase {
     #if os(macOS)
     // Gets the current path of this test file then
     // strips out the nested directories.
-    let filePath = URL(filePath: #file)
+    let filePath = URL(filePath: #filePath)
       .deletingLastPathComponent()
       .deletingLastPathComponent()
       .deletingLastPathComponent()
@@ -136,5 +140,4 @@ final class FlexBuffersReaderTests: XCTestCase {
     return FileManager.default.currentDirectoryPath
     #endif
   }
-
 }

tests/swift/Tests/Flexbuffers/FlexBuffersStringTests.swift

@@ -16,10 +16,12 @@
 
 import Common
 import FlexBuffers
-import XCTest
+import Foundation
+import Testing
 
-final class FlexBuffersStringTests: XCTestCase {
+struct FlexBuffersStringTests {
 
+  @Test
   func testEncodingUnicodeString() {
     let text = "プ画をみて✋"
 
@@ -38,6 +40,6 @@ final class FlexBuffersStringTests: XCTestCase {
       return String(data: data, encoding: .unicode)
     }
 
-    XCTAssertEqual(builtString, text)
+    #expect(builtString == text)
   }
 }

tests/swift/Tests/Flexbuffers/FlexBuffersWriterTests.swift

@@ -16,9 +16,10 @@
 
 import Common
 import FlexBuffers
-import XCTest
+import Testing
 
-final class FlexBuffersWriterTests: XCTestCase {
+struct FlexBuffersWriterTests {
+  @Test
   func testDeallocation() {
     let buf: ByteBuffer = {
       var fbx = FlexBuffersWriter()
@@ -28,12 +29,13 @@ final class FlexBuffersWriterTests: XCTestCase {
     }()
 
     buf.withUnsafeBytes {
-      XCTAssertEqual(
-        Array($0),
-        [5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
+      #expect(
+        Array($0) ==
+          [5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
     }
   }
 
+  @Test
   func testAddingVectorOfScalars() {
     var fbx = FlexBuffersWriter()
     fbx.vector {
@@ -45,8 +47,8 @@ final class FlexBuffersWriterTests: XCTestCase {
 
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [
           10, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 7, 0,
           0, 0, 8, 0, 0, 0, 9, 0, 0, 0, 20, 0, 0, 0, 1, 41, 46, 2, 40, 1,
@@ -55,6 +57,7 @@ final class FlexBuffersWriterTests: XCTestCase {
     }
   }
 
+  @Test
   func testAddingVectorOfUnsignedScalars() {
     var fbx = FlexBuffersWriter()
     fbx.vector {
@@ -66,8 +69,8 @@ final class FlexBuffersWriterTests: XCTestCase {
 
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [
           10, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
           0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0,
@@ -78,6 +81,7 @@ final class FlexBuffersWriterTests: XCTestCase {
     }
   }
 
+  @Test
   func testAddingVectorOfBools() {
     var fbx = FlexBuffersWriter()
     fbx.vector {
@@ -89,13 +93,14 @@ final class FlexBuffersWriterTests: XCTestCase {
 
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [4, 1, 0, 1, 0, 1, 5, 144, 2, 40, 1])
       // swiftformat:enable all
     }
   }
 
+  @Test
   func testSortingWithinMap() {
     var fbx = FlexBuffersWriter()
     fbx.map {
@@ -106,8 +111,8 @@ final class FlexBuffersWriterTests: XCTestCase {
     let buf: ByteBuffer = fbx.sizedByteBuffer
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [
           98, 111, 111, 108, 50, 0, 98, 111, 111, 108, 49, 0, 2, 7, 14, 2, 1, 2, 1, 0, 104, 104, 4,
           36, 1,
@@ -117,6 +122,7 @@ final class FlexBuffersWriterTests: XCTestCase {
     }
   }
 
+  @Test
   func testSharingKeyWithinMap() {
     var fbx = FlexBuffersWriter(initialSize: 1000, flags: .shareKeysAndStrings)
     fbx.map {
@@ -128,8 +134,8 @@ final class FlexBuffersWriterTests: XCTestCase {
     let buf: ByteBuffer = fbx.sizedByteBuffer
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [
           119, 101, 108, 99, 111, 109, 101, 0, 7, 119, 101, 108, 99, 111, 109, 101, 0, 3, 18, 19,
           20, 3, 1, 3, 15, 16, 17, 20, 20, 20, 6, 36, 1,
@@ -139,19 +145,21 @@ final class FlexBuffersWriterTests: XCTestCase {
     }
   }
 
+  @Test
   func testNestingVectorInMap() {
     let buf: ByteBuffer = createSizedBuffer()
 
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         flexbufferGolden
       )
       // swiftformat:enable all
     }
   }
 
+  @Test
   func testAddingNil() {
     var fbx = FlexBuffersWriter(
       initialSize: 8,
@@ -165,14 +173,15 @@ final class FlexBuffersWriterTests: XCTestCase {
     let buf: ByteBuffer = fbx.sizedByteBuffer
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [118, 0, 1, 3, 1, 1, 1, 0, 0, 2, 36, 1]
       )
       // swiftformat:enable all
     }
   }
 
+  @Test
   func testAddingManually() {
     var fbx = FlexBuffersWriter(
       initialSize: 8,
@@ -209,14 +218,15 @@ final class FlexBuffersWriterTests: XCTestCase {
     let buf: ByteBuffer = fbx.sizedByteBuffer
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         flexbufferGolden
       )
       // swiftformat:enable all
     }
   }
 
+  @Test
   func testEncodingAllTypes() {
     var fbx = FlexBuffersWriter()
     fbx.vector {
@@ -240,8 +250,8 @@ final class FlexBuffersWriterTests: XCTestCase {
 
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         allTypesGolden)
       // swiftformat:enable all
     }

tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/FlatBuffersMonsterWriterTests.swift

@@ -15,7 +15,7 @@
  */
 
 import Foundation
-import XCTest
+import Testing
 
 @testable import FlatBuffers
 
@@ -24,8 +24,9 @@ typealias Monster = MyGame_Example_Monster
 typealias Vec3 = MyGame_Example_Vec3
 typealias Stat = MyGame_Example_Stat
 
-class FlatBuffersMonsterWriterTests: XCTestCase {
+struct FlatBuffersMonsterWriterTests {
 
+  @Test
   func testData() {
     // swiftformat:disable all
     let data: [UInt8] = [
@@ -47,11 +48,12 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readVerifiedMonster(fb: _data)
   }
 
+  @Test
   func testCreateMonster() {
     let bytes = createMonster(withPrefix: false)
     // swiftformat:disable all
-    XCTAssertEqual(
-      bytes.sizedByteArray,
+    #expect(
+      bytes.sizedByteArray ==
       [
         48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28,
         0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0,
@@ -75,11 +77,12 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readMonster(monster: monster)
   }
 
+  @Test
   func testCreateMonsterResizedBuffer() {
     let bytes = createMonster(withPrefix: false)
     // swiftformat:disable all
-    XCTAssertEqual(
-      bytes.sizedByteArray,
+    #expect(
+      bytes.sizedByteArray ==
       [
         48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28,
         0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0,
@@ -98,11 +101,12 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readVerifiedMonster(fb: bytes.sizedBuffer)
   }
 
+  @Test
   func testCreateMonsterPrefixed() {
     let bytes = createMonster(withPrefix: true)
     // swiftformat:disable all
-    XCTAssertEqual(
-      bytes.sizedByteArray,
+    #expect(
+      bytes.sizedByteArray ==
       [
         44, 1, 0, 0, 44, 0, 0, 0, 77, 79, 78, 83, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28,
         0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0,
@@ -123,6 +127,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer))
   }
 
+  @Test
   func testCreateMonsterUsingCreateMonsterMethodWithNilPos() {
     var fbb = FlatBufferBuilder(initialSize: 1)
     let name = fbb.create(string: "Frodo")
@@ -132,10 +137,11 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     fbb.finish(offset: root)
     var buffer = fbb.sizedBuffer
     let newMonster: Monster = getRoot(byteBuffer: &buffer)
-    XCTAssertNil(newMonster.pos)
-    XCTAssertEqual(newMonster.name, "Frodo")
+    #expect(newMonster.pos == nil)
+    #expect(newMonster.name == "Frodo")
   }
 
+  @Test
   func testCreateMonsterUsingCreateMonsterMethodWithPosX() {
     var fbb = FlatBufferBuilder(initialSize: 1)
     let name = fbb.create(string: "Barney")
@@ -155,10 +161,11 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
 
     var buffer = fbb.sizedBuffer
     let newMonster: Monster = getRoot(byteBuffer: &buffer)
-    XCTAssertEqual(newMonster.pos!.x, 10)
-    XCTAssertEqual(newMonster.name, "Barney")
+    #expect(newMonster.pos!.x == 10)
+    #expect(newMonster.name == "Barney")
   }
 
+  @Test
   func testReadMonsterFromUnsafePointerWithoutCopying() {
     // swiftformat:disable all
     var array: [UInt8] = [
@@ -190,6 +197,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     readObjectApi(monster: unpacked)
   }
 
+  @Test
   func testArrayOfBools() {
     let boolArray = [false, true, false, true, false, true, false]
     var fbb = FlatBufferBuilder(initialSize: 1)
@@ -205,37 +213,41 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     let monster: Monster = getRoot(byteBuffer: &buffer)
     let values = monster.testarrayofbools
 
-    XCTAssertEqual(boolArray.count, values.count)
+    #expect(boolArray.count == values.count)
 
     for (index, bool) in monster.testarrayofbools.enumerated() {
-      XCTAssertEqual(bool, boolArray[index])
+      #expect(bool == boolArray[index])
     }
   }
 
   func readVerifiedMonster(fb: ByteBuffer) {
     var byteBuffer = fb
-    XCTAssertNoThrow(
+    do {
       try readMonster(
         monster: getCheckedRoot(
-          byteBuffer: &byteBuffer) as MyGame_Example_Monster))
+          byteBuffer: &byteBuffer) as MyGame_Example_Monster)
+    } catch {
+      Issue.record(error)
+    }
   }
 
+  @Test(.bug("https://github.com/google/flatbuffers/issues/8133"))
   func testUnalignedRead() {
     // Aligned read
     let fbb = createMonster(withPrefix: false)
     let testAligned: () -> Bool = {
       var buffer = fbb.sizedBuffer
       var monster: Monster = getRoot(byteBuffer: &buffer)
-      self.readFlatbufferMonster(monster: &monster)
+      readFlatbufferMonster(monster: &monster)
       return true
     }
-    XCTAssertEqual(testAligned(), true)
+    #expect(testAligned() == true)
     let testUnaligned: () -> Bool = {
       var bytes: [UInt8] = [0x00]
       bytes.append(contentsOf: fbb.sizedByteArray)
       return bytes.withUnsafeMutableBytes { ptr in
         guard var baseAddress = ptr.baseAddress else {
-          XCTFail("Base pointer is not defined")
+          Issue.record("Base pointer is not defined")
           return false
         }
         baseAddress = baseAddress.advanced(by: 1)
@@ -244,13 +256,14 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
           assumingMemoryBound: unlignedPtr,
           capacity: ptr.count - 1)
         var monster: Monster = getRoot(byteBuffer: &bytes)
-        self.readFlatbufferMonster(monster: &monster)
+        readFlatbufferMonster(monster: &monster)
         return true
       }
     }
-    XCTAssertEqual(testUnaligned(), true)
+    #expect(testUnaligned() == true)
   }
 
+  @Test
   func testReadingRemovedSizeUnalignedBuffer() {
     // Aligned read
     let fbb = createMonster(withPrefix: true)
@@ -259,7 +272,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
       bytes.append(contentsOf: fbb.sizedByteArray)
       return bytes.withUnsafeMutableBytes { ptr in
         guard var baseAddress = ptr.baseAddress else {
-          XCTFail("Base pointer is not defined")
+          Issue.record("Base pointer is not defined")
           return false
         }
         baseAddress = baseAddress.advanced(by: 1)
@@ -269,13 +282,14 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
           capacity: ptr.count - 1)
         var newBuf = FlatBuffersUtils.removeSizePrefix(bb: bytes)
         var monster: Monster = getRoot(byteBuffer: &newBuf)
-        self.readFlatbufferMonster(monster: &monster)
+        readFlatbufferMonster(monster: &monster)
         return true
       }
     }
-    XCTAssertEqual(testUnaligned(), true)
+    #expect(testUnaligned() == true)
   }
 
+  @Test
   func testForceRetainedObject() {
     let byteBuffer = {
       // swiftformat:disable all
@@ -381,95 +395,95 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     var fb = fb
 
     let monster: Monster = getRoot(byteBuffer: &fb)
-    XCTAssertFalse(monster.mutate(mana: 10))
-    XCTAssertEqual(monster.testarrayoftables[0].name, "Barney")
-    XCTAssertEqual(monster.testarrayoftables[1].name, "Frodo")
-    XCTAssertEqual(monster.testarrayoftables[2].name, "Wilma")
+    #expect(monster.mutate(mana: 10) == false)
+    #expect(monster.testarrayoftables[0].name == "Barney")
+    #expect(monster.testarrayoftables[1].name == "Frodo")
+    #expect(monster.testarrayoftables[2].name == "Wilma")
 
     // Example of searching for a table by the key
-    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo"))
-    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney"))
-    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma"))
+    #expect(monster.testarrayoftablesBy(key: "Frodo") != nil)
+    #expect(monster.testarrayoftablesBy(key: "Barney") != nil)
+    #expect(monster.testarrayoftablesBy(key: "Wilma") != nil)
 
-    XCTAssertEqual(monster.testType, .monster)
+    #expect(monster.testType == .monster)
 
-    XCTAssertEqual(monster.mutate(inventory: 1, at: 0), true)
-    XCTAssertEqual(monster.mutate(inventory: 2, at: 1), true)
-    XCTAssertEqual(monster.mutate(inventory: 3, at: 2), true)
-    XCTAssertEqual(monster.mutate(inventory: 4, at: 3), true)
-    XCTAssertEqual(monster.mutate(inventory: 5, at: 4), true)
+    #expect(monster.mutate(inventory: 1, at: 0) == true)
+    #expect(monster.mutate(inventory: 2, at: 1) == true)
+    #expect(monster.mutate(inventory: 3, at: 2) == true)
+    #expect(monster.mutate(inventory: 4, at: 3) == true)
+    #expect(monster.mutate(inventory: 5, at: 4) == true)
 
     for i in 0..<monster.inventory.count {
-      XCTAssertEqual(monster.inventory[i], Byte(i + 1))
+      #expect(monster.inventory[i] == Byte(i + 1))
     }
 
-    XCTAssertEqual(monster.mutate(inventory: 0, at: 0), true)
-    XCTAssertEqual(monster.mutate(inventory: 1, at: 1), true)
-    XCTAssertEqual(monster.mutate(inventory: 2, at: 2), true)
-    XCTAssertEqual(monster.mutate(inventory: 3, at: 3), true)
-    XCTAssertEqual(monster.mutate(inventory: 4, at: 4), true)
+    #expect(monster.mutate(inventory: 0, at: 0) == true)
+    #expect(monster.mutate(inventory: 1, at: 1) == true)
+    #expect(monster.mutate(inventory: 2, at: 2) == true)
+    #expect(monster.mutate(inventory: 3, at: 3) == true)
+    #expect(monster.mutate(inventory: 4, at: 4) == true)
 
     let vec = monster.mutablePos
-    XCTAssertEqual(vec?.x, 1)
-    XCTAssertTrue(vec?.mutate(x: 55.0) ?? false)
-    XCTAssertTrue(vec?.mutate(test1: 55) ?? false)
-    XCTAssertEqual(vec?.x, 55.0)
-    XCTAssertEqual(vec?.test1, 55.0)
-    XCTAssertTrue(vec?.mutate(x: 1) ?? false)
-    XCTAssertEqual(vec?.x, 1)
-    XCTAssertTrue(vec?.mutate(test1: 3) ?? false)
+    #expect(vec?.x == 1)
+    #expect(vec?.mutate(x: 55.0) == true)
+    #expect(vec?.mutate(test1: 55) == true)
+    #expect(vec?.x == 55.0)
+    #expect(vec?.test1 == 55.0)
+    #expect(vec?.mutate(x: 1) == true)
+    #expect(vec?.x == 1)
+    #expect(vec?.mutate(test1: 3) == true)
 
     let mutableTest4 = monster.mutableTest4
     let orignalValues = mutableTest4[0].a
-    XCTAssertEqual(mutableTest4[0].mutate(a: 100), true)
-    XCTAssertNotEqual(monster.test4[0].a, orignalValues)
-    XCTAssertEqual(monster.test4[0].a, 100)
-    XCTAssertEqual(mutableTest4[0].mutate(a: orignalValues), true)
+    #expect(mutableTest4[0].mutate(a: 100) == true)
+    #expect(monster.test4[0].a != orignalValues)
+    #expect(monster.test4[0].a == 100)
+    #expect(mutableTest4[0].mutate(a: orignalValues) == true)
   }
 
   func readFlatbufferMonster(monster: inout MyGame_Example_Monster) {
-    XCTAssertEqual(monster.hp, 80)
-    XCTAssertEqual(monster.mana, 150)
-    XCTAssertEqual(monster.name, "MyMonster")
+    #expect(monster.hp == 80)
+    #expect(monster.mana == 150)
+    #expect(monster.name == "MyMonster")
     let pos = monster.pos
-    XCTAssertEqual(pos?.x, 1)
-    XCTAssertEqual(pos?.y, 2)
-    XCTAssertEqual(pos?.z, 3)
-    XCTAssertEqual(pos?.test1, 3)
-    XCTAssertEqual(pos?.test2, .green)
+    #expect(pos?.x == 1)
+    #expect(pos?.y == 2)
+    #expect(pos?.z == 3)
+    #expect(pos?.test1 == 3)
+    #expect(pos?.test2 == .green)
     let test = pos?.test3
-    XCTAssertEqual(test?.a, 5)
-    XCTAssertEqual(test?.b, 6)
-    XCTAssertEqual(monster.testType, .monster)
+    #expect(test?.a == 5)
+    #expect(test?.b == 6)
+    #expect(monster.testType == .monster)
     let monster2 = monster.test(type: Monster.self)
-    XCTAssertEqual(monster2?.name, "Fred")
+    #expect(monster2?.name == "Fred")
 
-    XCTAssertEqual(monster.mutate(mana: 10), false)
+    #expect(monster.mutate(mana: 10) == false)
 
-    XCTAssertEqual(monster.mana, 150)
-    XCTAssertEqual(monster.inventory.count, 5)
+    #expect(monster.mana == 150)
+    #expect(monster.inventory.count == 5)
     var sum: Byte = 0
     for inventory in monster.inventory {
       sum += inventory
     }
-    XCTAssertEqual(sum, 10)
+    #expect(sum == 10)
 
     monster.withUnsafePointerToInventory { ptr, count in
       var sum: UInt8 = 0
       for pointee in ptr.startIndex..<ptr.endIndex {
         sum += ptr[pointee]
       }
-      XCTAssertEqual(sum, 10)
+      #expect(sum == 10)
     }
 
-    XCTAssertEqual(monster.test4.count, 2)
+    #expect(monster.test4.count == 2)
 
     let test4 = monster.test4
     var sum0 = 0
     for test0 in test4 {
       sum0 += Int(test0.a) + Int(test0.b)
     }
-    XCTAssertEqual(sum0, 100)
+    #expect(sum0 == 100)
 
     monster.withUnsafePointerToTest4 { ptr, count in
       guard let ptr = ptr.baseAddress else { return }
@@ -485,7 +499,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
         pointerSum += Int(bindedMemory[pointee].a) +
           Int(bindedMemory[pointee].b)
       }
-      XCTAssertEqual(pointerSum, 100)
+      #expect(pointerSum == 100)
     }
 
     let mutableTest4 = monster.mutableTest4
@@ -493,87 +507,84 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     for test0 in mutableTest4 {
       sum2 += Int(test0.a) + Int(test0.b)
     }
-    XCTAssertEqual(sum2, 100)
+    #expect(sum2 == 100)
 
     let stringArray = monster.testarrayofstring
-    XCTAssertEqual(stringArray.count, 2)
-    XCTAssertEqual(stringArray[0], "test1")
-    XCTAssertEqual(stringArray[1], "test2")
-    XCTAssertEqual(monster.testbool, true)
+    #expect(stringArray.count == 2)
+    #expect(stringArray[0] == "test1")
+    #expect(stringArray[1] == "test2")
+    #expect(monster.testbool == true)
 
     let array = monster.nameSegmentArray
-    XCTAssertEqual(String(bytes: array ?? [], encoding: .utf8), "MyMonster")
+    #expect(String(bytes: array ?? [], encoding: .utf8) == "MyMonster")
 
     if 0 == monster.testarrayofbools.count {
-      XCTAssertEqual(monster.testarrayofbools.isEmpty, true)
+      #expect(monster.testarrayofbools.isEmpty == true)
     } else {
-      XCTAssertEqual(monster.testarrayofbools.isEmpty, false)
+      #expect(monster.testarrayofbools.isEmpty == false)
     }
   }
 
   func readObjectApi(monster: MyGame_Example_MonsterT) {
-    XCTAssertEqual(monster.hp, 80)
-    XCTAssertEqual(monster.mana, 150)
-    XCTAssertEqual(monster.name, "MyMonster")
+    #expect(monster.hp == 80)
+    #expect(monster.mana == 150)
+    #expect(monster.name == "MyMonster")
     let pos = monster.pos
-    XCTAssertEqual(pos?.x, 1)
-    XCTAssertEqual(pos?.y, 2)
-    XCTAssertEqual(pos?.z, 3)
-    XCTAssertEqual(pos?.test1, 3)
-    XCTAssertEqual(pos?.test2, .green)
+    #expect(pos?.x == 1)
+    #expect(pos?.y == 2)
+    #expect(pos?.z == 3)
+    #expect(pos?.test1 == 3)
+    #expect(pos?.test2 == .green)
     let test = pos?.test3
-    XCTAssertEqual(test?.a, 5)
-    XCTAssertEqual(test?.b, 6)
+    #expect(test?.a == 5)
+    #expect(test?.b == 6)
     let monster2 = monster.test?.value as? MyGame_Example_MonsterT
-    XCTAssertEqual(monster2?.name, "Fred")
-    XCTAssertEqual(monster.mana, 150)
+    #expect(monster2?.name == "Fred")
+    #expect(monster.mana == 150)
     monster.mana = 10
-    XCTAssertEqual(monster.mana, 10)
+    #expect(monster.mana == 10)
     monster.mana = 150
-    XCTAssertEqual(monster.mana, 150)
+    #expect(monster.mana == 150)
 
-    XCTAssertEqual(monster.inventory.count, 5)
+    #expect(monster.inventory.count == 5)
     var sum: Byte = 0
     for i in monster.inventory {
       sum += i
     }
-    XCTAssertEqual(sum, 10)
-    XCTAssertEqual(monster.test4.count, 2)
+    #expect(sum == 10)
+    #expect(monster.test4.count == 2)
     var sum0 = 0
     for test in monster.test4 {
       sum0 += Int(test.a) + Int(test.b)
     }
-    XCTAssertEqual(sum0, 100)
-    XCTAssertEqual(monster.testbool, true)
+    #expect(sum0 == 100)
+    #expect(monster.testbool == true)
   }
 
-  func testEncoding() {
+  @Test
+  func testEncoding() throws {
     let fbb = createMonster(withPrefix: false)
     var sizedBuffer = fbb.sizedBuffer
-    do {
-      struct Test: Decodable {
-        struct Pos: Decodable {
-          let x, y, z: Int
-        }
-        let hp: Int
-        let inventory: [UInt8]
-        let name: String
-        let pos: Pos
+    struct Test: Decodable {
+      struct Pos: Decodable {
+        let x, y, z: Int
       }
-      let reader: Monster = try getCheckedRoot(byteBuffer: &sizedBuffer)
-      let encoder = JSONEncoder()
-      encoder.keyEncodingStrategy = .convertToSnakeCase
-      let data = try encoder.encode(reader)
-      let decoder = JSONDecoder()
-      decoder.keyDecodingStrategy = .convertFromSnakeCase
-      let value = try decoder.decode(Test.self, from: data)
-      XCTAssertEqual(value.name, "MyMonster")
-      XCTAssertEqual(value.pos.x, 1)
-      XCTAssertEqual(value.pos.y, 2)
-      XCTAssertEqual(value.pos.z, 3)
-    } catch {
-      XCTFail(error.localizedDescription)
+      let hp: Int
+      let inventory: [UInt8]
+      let name: String
+      let pos: Pos
     }
+    let reader: Monster = try getCheckedRoot(byteBuffer: &sizedBuffer)
+    let encoder = JSONEncoder()
+    encoder.keyEncodingStrategy = .convertToSnakeCase
+    let data = try encoder.encode(reader)
+    let decoder = JSONDecoder()
+    decoder.keyDecodingStrategy = .convertFromSnakeCase
+    let value = try decoder.decode(Test.self, from: data)
+    #expect(value.name == "MyMonster")
+    #expect(value.pos.x == 1)
+    #expect(value.pos.y == 2)
+    #expect(value.pos.z == 3)
   }
 
   var jsonData: String {

tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift

@@ -662,7 +662,7 @@ public struct MyGame_Example_StructOfStructsOfStructs_Mutable: FlatBufferStruct,
   }
 }
 
-public struct MyGame_InParentNamespace: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_InParentNamespace: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -712,7 +712,7 @@ public class MyGame_InParentNamespaceT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_InParentNamespace.self) }
 
 }
-public struct MyGame_Example2_Monster: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example2_Monster: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -762,7 +762,7 @@ public class MyGame_Example2_MonsterT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example2_Monster.self) }
 
 }
-internal struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+internal struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   internal var __buffer: ByteBuffer! { return _accessor.bb }
@@ -840,7 +840,7 @@ internal class MyGame_Example_TestSimpleTableWithEnumT: NativeObject {
   internal func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TestSimpleTableWithEnum.self) }
 
 }
-public struct MyGame_Example_Stat: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example_Stat: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -976,7 +976,7 @@ public class MyGame_Example_StatT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Stat.self) }
 
 }
-public struct MyGame_Example_Referrable: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example_Referrable: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -1079,7 +1079,7 @@ public class MyGame_Example_ReferrableT: NativeObject {
 
 }
 ///  an example documentation comment: "monster object"
-public struct MyGame_Example_Monster: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example_Monster: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -2213,7 +2213,7 @@ public class MyGame_Example_MonsterT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }
 
 }
-public struct MyGame_Example_TypeAliases: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct MyGame_Example_TypeAliases: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersJSONTests.swift

@@ -16,17 +16,19 @@
 
 import Common
 import FlexBuffers
-import XCTest
+import Foundation
+import Testing
 
-final class FlexBuffersJSONTests: XCTestCase {
+struct FlexBuffersJSONTests {
+  @Test
   func testEncodingJSON() throws {
     let buf: ByteBuffer = createProperBuffer().sizedByteBuffer
     let reference = try getRoot(buffer: buf)!
 
     let json = reference.jsonString()
     // swiftformat:disable all
-    XCTAssertEqual(
-      json,
+    #expect(
+      json ==
       "{\"bar\": [1, 2, 3], \"bar3\": [1, 2, 3], \"bool\": true, \"bools\": [true, false, true, false], \"foo\": 100.0, \"mymap\": {\"foo\": \"Fred\"}, \"vec\": [-100, \"Fred\", 4.0, \"M\", false, 4.0]}"
     )
     // swiftformat:enable all
@@ -37,15 +39,15 @@ final class FlexBuffersJSONTests: XCTestCase {
         with: data,
         options: []) as! [String: Any]
 
-    XCTAssertEqual(decodedData["bar"] as! [Int], [1, 2, 3])
-    XCTAssertEqual(decodedData["bar3"] as! [Int], [1, 2, 3])
+    #expect(decodedData["bar"] as! [Int] == [1, 2, 3])
+    #expect(decodedData["bar3"] as! [Int] == [1, 2, 3])
 
     let vec: [Any] = decodedData["vec"] as! [Any]
-    XCTAssertEqual(vec[0] as! Int, -100)
-    XCTAssertEqual(vec[1] as! String, "Fred")
-    XCTAssertEqual(vec[2] as! Double, 4.0)
-    XCTAssertEqual(vec[3] as! String, "M")
-    XCTAssertEqual(vec[4] as! Bool, false)
-    XCTAssertEqual(vec[5] as! Double, 4.0)
+    #expect(vec[0] as! Int == -100)
+    #expect(vec[1] as! String == "Fred")
+    #expect(vec[2] as! Double == 4.0)
+    #expect(vec[3] as! String == "M")
+    #expect(vec[4] as! Bool == false)
+    #expect(vec[5] as! Double == 4.0)
   }
 }

tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersReaderTests.swift

@@ -15,22 +15,26 @@
  */
 
 import Common
-import XCTest
+import Foundation
+import Testing
 
 @testable import FlexBuffers
 
-final class FlexBuffersReaderTests: XCTestCase {
+struct FlexBuffersReaderTests {
 
+  @Test
   func testReadingProperBuffer() throws {
     let buf: ByteBuffer = createProperBuffer().byteBuffer
     try validate(buffer: buf)
   }
 
+  @Test
   func testReadingSizedBuffer() throws {
     let buf: ByteBuffer = createSizedBuffer()
     try validate(buffer: buf)
   }
 
+  @Test(.bug("https://github.com/google/flatbuffers/issues/8642"))
   func testReset() throws {
     var fbx = FlexBuffersWriter(
       initialSize: 8,
@@ -38,87 +42,87 @@ final class FlexBuffersReaderTests: XCTestCase {
     write(fbx: &fbx)
 
     try validate(buffer: ByteBuffer(bytes: fbx.sizedByteArray))
-    XCTAssertEqual(fbx.capacity, 512)
+    #expect(fbx.capacity == 512)
     fbx.reset()
-    XCTAssertEqual(fbx.writerIndex, 0)
-    XCTAssertEqual(fbx.capacity, 8)
+    #expect(fbx.writerIndex == 0)
+    #expect(fbx.capacity == 8)
 
     write(fbx: &fbx)
     try validate(buffer: ByteBuffer(bytes: fbx.sizedByteArray))
     fbx.reset(keepingCapacity: true)
-    XCTAssertEqual(fbx.writerIndex, 0)
-    XCTAssertEqual(fbx.capacity, 512)
+    #expect(fbx.writerIndex == 0)
+    #expect(fbx.capacity == 512)
 
     write(fbx: &fbx)
     try validate(buffer: ByteBuffer(bytes: fbx.sizedByteArray))
-    XCTAssertEqual(fbx.capacity, 512)
+    #expect(fbx.capacity == 512)
   }
 
   private func validate(buffer buf: ByteBuffer) throws {
     let reference = try getRoot(buffer: buf)!
-    XCTAssertEqual(reference.type, .map)
+    #expect(reference.type == .map)
     let map = reference.map!
-    XCTAssertEqual(map.count, 7)
+    #expect(map.count == 7)
     let vecRef = map["vec"]!
-    XCTAssertEqual(vecRef.type, .vector)
+    #expect(vecRef.type == .vector)
     let vec = vecRef.vector!
-    XCTAssertEqual(vec.count, 6)
-    XCTAssertEqual(vec[0]?.type, .int)
-    XCTAssertEqual(vec[0]?.int, -100)
-    XCTAssertEqual(vec[1]?.type, .string)
-    XCTAssertEqual(vec[1]?.cString, "Fred")
-    XCTAssertNil(vec[1]?.int)
-    XCTAssertEqual(vec[2]?.double, 4.0)
-    XCTAssertTrue(vec[3]?.type == .blob)
+    #expect(vec.count == 6)
+    #expect(vec[0]?.type == .int)
+    #expect(vec[0]?.int == -100)
+    #expect(vec[1]?.type == .string)
+    #expect(vec[1]?.cString == "Fred")
+    #expect(vec[1]?.int == nil)
+    #expect(vec[2]?.double == 4.0)
+    #expect(vec[3]?.type == .blob)
 
     let blob = vec[3]!.blob { pointer in
       Array(pointer)
     }
 
-    XCTAssertEqual(blob?.count, 1)
-    XCTAssertEqual(blob?[0], 77)
-    XCTAssertEqual(vec[4]?.type, .bool)
-    XCTAssertEqual(vec[4]?.bool, false)
-    XCTAssertEqual(vec[5]?.double, 4.0)  // Shared with vec[2]
+    #expect(blob?.count == 1)
+    #expect(blob?[0] == 77)
+    #expect(vec[4]?.type == .bool)
+    #expect(vec[4]?.bool == false)
+    #expect(vec[5]?.double == 4.0)  // Shared with vec[2]
 
     let barVec = map["bar"]!.typedVector!
-    XCTAssertEqual(barVec.count, 3)
-    XCTAssertEqual(barVec[2]?.int, 3)
-    XCTAssertEqual(barVec[2]?.asInt(), UInt8(3))
+    #expect(barVec.count == 3)
+    #expect(barVec[2]?.int == 3)
+    #expect(barVec[2]?.asInt() == UInt8(3))
 
     let fixedVec = map["bar3"]!.fixedTypedVector!
-    XCTAssertEqual(fixedVec.count, 3)
-    XCTAssertEqual(fixedVec[2]?.int, 3)
-    XCTAssertEqual(fixedVec[2]?.asInt(), UInt8(3))
-    XCTAssertEqual(map["bool"]?.bool, true)
+    #expect(fixedVec.count == 3)
+    #expect(fixedVec[2]?.int == 3)
+    #expect(fixedVec[2]?.asInt() == UInt8(3))
+    #expect(map["bool"]?.bool == true)
 
     let boolsVector = map["bools"]!.typedVector!
-    XCTAssertEqual(boolsVector.type, .bool)
-    XCTAssertEqual(boolsVector[0]?.bool, true)
-    XCTAssertEqual(boolsVector[1]?.bool, false)
+    #expect(boolsVector.type == .bool)
+    #expect(boolsVector[0]?.bool == true)
+    #expect(boolsVector[1]?.bool == false)
 
     let bools = [true, false, true, false]
     boolsVector.withUnsafeRawBufferPointer { buff in
       for i in 0..<boolsVector.count {
-        XCTAssertEqual(buff.load(fromByteOffset: i, as: Bool.self), bools[i])
+        #expect(buff.load(fromByteOffset: i, as: Bool.self) == bools[i])
       }
     }
-    XCTAssertEqual(map["foo"]?.double, 100)
-    XCTAssertNil(map["unknown"])
+    #expect(map["foo"]?.double == 100)
+    #expect(map["unknown"] == nil)
     let mymap = map["mymap"]?.map
 
     // Check if both addresses used are the same for keys and strings
-    XCTAssertEqual(mymap?.keys[0]?.cString, map.keys[4]?.cString)
+    #expect(mymap?.keys[0]?.cString == map.keys[4]?.cString)
     map.keys[4]?.withUnsafeRawPointer { pointer in
       mymap?.keys[0]?.withUnsafeRawPointer { mymapPointer in
-        XCTAssertEqual(pointer, mymapPointer)
+        #expect(pointer == mymapPointer)
       }
     }
 
-    XCTAssertEqual(mymap?.values[0]?.cString, vec[1]?.cString)
+    #expect(mymap?.values[0]?.cString == vec[1]?.cString)
     vec[1]?.withUnsafeRawPointer { pointer in
       mymap?.values[0]?.withUnsafeRawPointer { mymapPointer in
-        XCTAssertEqual(pointer, mymapPointer)
+        #expect(pointer == mymapPointer)
       }
     }
   }
@@ -127,7 +131,7 @@ final class FlexBuffersReaderTests: XCTestCase {
     #if os(macOS)
     // Gets the current path of this test file then
     // strips out the nested directories.
-    let filePath = URL(filePath: #file)
+    let filePath = URL(filePath: #filePath)
       .deletingLastPathComponent()
       .deletingLastPathComponent()
       .deletingLastPathComponent()

tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersStringTests.swift

@@ -16,10 +16,12 @@
 
 import Common
 import FlexBuffers
-import XCTest
+import Foundation
+import Testing
 
-final class FlexBuffersStringTests: XCTestCase {
+struct FlexBuffersStringTests {
 
+  @Test
   func testEncodingUnicodeString() {
     let text = "プ画をみて✋"
 
@@ -38,6 +40,6 @@ final class FlexBuffersStringTests: XCTestCase {
       return String(data: data, encoding: .unicode)
     }
 
-    XCTAssertEqual(builtString, text)
+    #expect(builtString == text)
   }
 }

tests/swift/Wasm.tests/Tests/FlexBuffers.Test.Swift.WasmTests/FlexBuffersWriterTests.swift

@@ -16,9 +16,10 @@
 
 import Common
 import FlexBuffers
-import XCTest
+import Testing
 
-final class FlexBuffersWriterTests: XCTestCase {
+struct FlexBuffersWriterTests {
+  @Test
   func testDeallocation() {
     let buf: ByteBuffer = {
       var fbx = FlexBuffersWriter()
@@ -28,12 +29,13 @@ final class FlexBuffersWriterTests: XCTestCase {
     }()
 
     buf.withUnsafeBytes {
-      XCTAssertEqual(
-        Array($0),
-        [5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
+      #expect(
+        Array($0) ==
+          [5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
     }
   }
 
+  @Test
   func testAddingVectorOfScalars() {
     var fbx = FlexBuffersWriter()
     fbx.vector {
@@ -45,8 +47,8 @@ final class FlexBuffersWriterTests: XCTestCase {
 
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [
           10, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 7, 0,
           0, 0, 8, 0, 0, 0, 9, 0, 0, 0, 20, 0, 0, 0, 1, 41, 46, 2, 40, 1,
@@ -55,6 +57,7 @@ final class FlexBuffersWriterTests: XCTestCase {
     }
   }
 
+  @Test
   func testAddingVectorOfUnsignedScalars() {
     var fbx = FlexBuffersWriter()
     fbx.vector {
@@ -66,8 +69,8 @@ final class FlexBuffersWriterTests: XCTestCase {
 
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [
           10, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
           0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0,
@@ -78,6 +81,7 @@ final class FlexBuffersWriterTests: XCTestCase {
     }
   }
 
+  @Test
   func testAddingVectorOfBools() {
     var fbx = FlexBuffersWriter()
     fbx.vector {
@@ -89,13 +93,14 @@ final class FlexBuffersWriterTests: XCTestCase {
 
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [4, 1, 0, 1, 0, 1, 5, 144, 2, 40, 1])
       // swiftformat:enable all
     }
   }
 
+  @Test
   func testSortingWithinMap() {
     var fbx = FlexBuffersWriter()
     fbx.map {
@@ -106,8 +111,8 @@ final class FlexBuffersWriterTests: XCTestCase {
     let buf: ByteBuffer = fbx.sizedByteBuffer
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [
           98, 111, 111, 108, 50, 0, 98, 111, 111, 108, 49, 0, 2, 7, 14, 2, 1, 2, 1, 0, 104, 104, 4,
           36, 1,
@@ -117,6 +122,7 @@ final class FlexBuffersWriterTests: XCTestCase {
     }
   }
 
+  @Test
   func testSharingKeyWithinMap() {
     var fbx = FlexBuffersWriter(initialSize: 1000, flags: .shareKeysAndStrings)
     fbx.map {
@@ -128,8 +134,8 @@ final class FlexBuffersWriterTests: XCTestCase {
     let buf: ByteBuffer = fbx.sizedByteBuffer
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [
           119, 101, 108, 99, 111, 109, 101, 0, 7, 119, 101, 108, 99, 111, 109, 101, 0, 3, 18, 19,
           20, 3, 1, 3, 15, 16, 17, 20, 20, 20, 6, 36, 1,
@@ -139,19 +145,21 @@ final class FlexBuffersWriterTests: XCTestCase {
     }
   }
 
+  @Test
   func testNestingVectorInMap() {
     let buf: ByteBuffer = createSizedBuffer()
 
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         flexbufferGolden
       )
       // swiftformat:enable all
     }
   }
 
+  @Test
   func testAddingNil() {
     var fbx = FlexBuffersWriter(
       initialSize: 8,
@@ -165,14 +173,15 @@ final class FlexBuffersWriterTests: XCTestCase {
     let buf: ByteBuffer = fbx.sizedByteBuffer
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         [118, 0, 1, 3, 1, 1, 1, 0, 0, 2, 36, 1]
       )
       // swiftformat:enable all
     }
   }
 
+  @Test
   func testAddingManually() {
     var fbx = FlexBuffersWriter(
       initialSize: 8,
@@ -209,14 +218,15 @@ final class FlexBuffersWriterTests: XCTestCase {
     let buf: ByteBuffer = fbx.sizedByteBuffer
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         flexbufferGolden
       )
       // swiftformat:enable all
     }
   }
 
+  @Test
   func testEncodingAllTypes() {
     var fbx = FlexBuffersWriter()
     fbx.vector {
@@ -240,8 +250,8 @@ final class FlexBuffersWriterTests: XCTestCase {
 
     buf.withUnsafeBytes {
       // swiftformat:disable all
-      XCTAssertEqual(
-        Array($0),
+      #expect(
+        Array($0) ==
         allTypesGolden)
       // swiftformat:enable all
     }

tests/swift/fuzzer/CodeGenerationTests/test_import_generated.swift

@@ -3,12 +3,12 @@
 // swiftformat:disable all
 
 #if canImport(Common)
-@_implementationOnly import Common
+internal import Common
 #endif
 
-@_implementationOnly import FlatBuffers
+internal import FlatBuffers
 
-internal struct Message: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+internal struct Message: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   internal var __buffer: ByteBuffer! { return _accessor.bb }

tests/swift/fuzzer/CodeGenerationTests/test_no_include_generated.swift

@@ -68,7 +68,7 @@ public struct BytesCount_Mutable: FlatBufferStruct, FlatbuffersVectorInitializab
   }
 }
 
-public struct InternalMessage: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct InternalMessage: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
@@ -148,7 +148,7 @@ public class InternalMessageT: NativeObject {
   public func serialize() -> ByteBuffer { return serialize(type: InternalMessage.self) }
 
 }
-public struct Message: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
+public struct Message: FlatBufferVerifiableTable, FlatbuffersVectorInitializable, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }

tests/ts/TypeScriptTest.py

@@ -228,11 +228,6 @@ print(
     " no_import_ext..."
 )
 check_call(["../../node_modules/.bin/tsc", "-p", "./tsconfig.node.json"])
-print(
-    "Running TypeScript Compiler with isolatedDeclarations and"
-    " isolatedModules..."
-)
-check_call(["../../node_modules/.bin/tsc", "-p", "./tsconfig.isolated.json"])
 
 NODE_CMD = ["node"]
 

tests/ts/abc.ts

@@ -1,9 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-
-export enum ABC {
-  A = 0,
-  B = 1,
-  C = 2
-}

tests/ts/arrays_test_complex/my-game/example.d.ts

@@ -1,6 +1,6 @@
-export { ArrayStruct, ArrayStructT } from './example/array-struct.js';
-export { ArrayTable, ArrayTableT } from './example/array-table.js';
-export { InnerStruct, InnerStructT } from './example/inner-struct.js';
-export { NestedStruct, NestedStructT } from './example/nested-struct.js';
-export { OuterStruct, OuterStructT } from './example/outer-struct.js';
-export { TestEnum } from './example/test-enum.js';
+export {ArrayStruct, ArrayStructT} from './example/array-struct.js';
+export {ArrayTable, ArrayTableT} from './example/array-table.js';
+export {InnerStruct, InnerStructT} from './example/inner-struct.js';
+export {NestedStruct, NestedStructT} from './example/nested-struct.js';
+export {OuterStruct, OuterStructT} from './example/outer-struct.js';
+export {TestEnum} from './example/test-enum.js';

tests/ts/arrays_test_complex/my-game/example.js

@@ -1,8 +1,9 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-export { ArrayStruct, ArrayStructT } from './example/array-struct.js';
-export { ArrayTable, ArrayTableT } from './example/array-table.js';
-export { InnerStruct, InnerStructT } from './example/inner-struct.js';
-export { NestedStruct, NestedStructT } from './example/nested-struct.js';
-export { OuterStruct, OuterStructT } from './example/outer-struct.js';
-export { TestEnum } from './example/test-enum.js';
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any,
+ * @typescript-eslint/no-non-null-assertion */
+export {ArrayStruct, ArrayStructT} from './example/array-struct.js';
+export {ArrayTable, ArrayTableT} from './example/array-table.js';
+export {InnerStruct, InnerStructT} from './example/inner-struct.js';
+export {NestedStruct, NestedStructT} from './example/nested-struct.js';
+export {OuterStruct, OuterStructT} from './example/outer-struct.js';
+export {TestEnum} from './example/test-enum.js';

tests/ts/arrays_test_complex/my-game/example/array-struct.d.ts

@@ -1,31 +1,53 @@
 import * as flatbuffers from 'flatbuffers';
-import { NestedStruct, NestedStructT } from './nested-struct.js';
-import { OuterStruct, OuterStructT } from './outer-struct.js';
-export declare class ArrayStruct implements flatbuffers.IUnpackableObject<ArrayStructT> {
-    bb: flatbuffers.ByteBuffer | null;
-    bb_pos: number;
-    __init(i: number, bb: flatbuffers.ByteBuffer): ArrayStruct;
-    aUnderscore(): number;
-    bUnderscore(index: number): number | null;
-    c(): number;
-    d(index: number, obj?: NestedStruct): NestedStruct | null;
-    e(): number;
-    f(index: number, obj?: OuterStruct): OuterStruct | null;
-    g(index: number): bigint | null;
-    static getFullyQualifiedName(): "MyGame.Example.ArrayStruct";
-    static sizeOf(): number;
-    static createArrayStruct(builder: flatbuffers.Builder, a_underscore: number, b_underscore: number[], c: number, d: (any | NestedStructT)[], e: number, f: (any | OuterStructT)[], g: bigint[]): flatbuffers.Offset;
-    unpack(): ArrayStructT;
-    unpackTo(_o: ArrayStructT): void;
+import {
+  NestedStruct,
+  NestedStructT,
+} from '../../my-game/example/nested-struct.js';
+import {OuterStruct, OuterStructT} from '../../my-game/example/outer-struct.js';
+export declare class ArrayStruct
+  implements flatbuffers.IUnpackableObject<ArrayStructT>
+{
+  bb: flatbuffers.ByteBuffer | null;
+  bb_pos: number;
+  __init(i: number, bb: flatbuffers.ByteBuffer): ArrayStruct;
+  aUnderscore(): number;
+  bUnderscore(index: number): number | null;
+  c(): number;
+  d(index: number, obj?: NestedStruct): NestedStruct | null;
+  e(): number;
+  f(index: number, obj?: OuterStruct): OuterStruct | null;
+  g(index: number): bigint | null;
+  static getFullyQualifiedName(): string;
+  static sizeOf(): number;
+  static createArrayStruct(
+    builder: flatbuffers.Builder,
+    a_underscore: number,
+    b_underscore: number[] | null,
+    c: number,
+    d: (any | NestedStructT)[] | null,
+    e: number,
+    f: (any | OuterStructT)[] | null,
+    g: bigint[] | null,
+  ): flatbuffers.Offset;
+  unpack(): ArrayStructT;
+  unpackTo(_o: ArrayStructT): void;
 }
 export declare class ArrayStructT implements flatbuffers.IGeneratedObject {
-    aUnderscore: number;
-    bUnderscore: (number)[];
-    c: number;
-    d: (NestedStructT)[];
-    e: number;
-    f: (OuterStructT)[];
-    g: (bigint)[];
-    constructor(aUnderscore?: number, bUnderscore?: (number)[], c?: number, d?: (NestedStructT)[], e?: number, f?: (OuterStructT)[], g?: (bigint)[]);
-    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+  aUnderscore: number;
+  bUnderscore: number[];
+  c: number;
+  d: NestedStructT[];
+  e: number;
+  f: OuterStructT[];
+  g: bigint[];
+  constructor(
+    aUnderscore?: number,
+    bUnderscore?: number[],
+    c?: number,
+    d?: NestedStructT[],
+    e?: number,
+    f?: OuterStructT[],
+    g?: bigint[],
+  );
+  pack(builder: flatbuffers.Builder): flatbuffers.Offset;
 }

tests/ts/arrays_test_complex/my-game/example/array-struct.js

@@ -1,98 +1,115 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-import { NestedStruct, NestedStructT } from './nested-struct.js';
-import { OuterStruct, OuterStructT } from './outer-struct.js';
+import {NestedStruct, NestedStructT} from '../../my-game/example/nested-struct.js';
+import {OuterStruct, OuterStructT} from '../../my-game/example/outer-struct.js';
 export class ArrayStruct {
-    constructor() {
-        this.bb = null;
-        this.bb_pos = 0;
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  aUnderscore() {
+    return this.bb.readFloat32(this.bb_pos);
+  }
+  bUnderscore(index) {
+    return this.bb.readInt32(this.bb_pos + 4 + index * 4);
+  }
+  c() {
+    return this.bb.readInt8(this.bb_pos + 64);
+  }
+  d(index, obj) {
+    return (obj || new NestedStruct())
+        .__init(this.bb_pos + 72 + index * 1072, this.bb);
+  }
+  e() {
+    return this.bb.readInt32(this.bb_pos + 2216);
+  }
+  f(index, obj) {
+    return (obj || new OuterStruct())
+        .__init(this.bb_pos + 2224 + index * 208, this.bb);
+  }
+  g(index) {
+    return this.bb.readInt64(this.bb_pos + 2640 + index * 8);
+  }
+  static getFullyQualifiedName() {
+    return 'MyGame.Example.ArrayStruct';
+  }
+  static sizeOf() {
+    return 2656;
+  }
+  static createArrayStruct(builder, a_underscore, b_underscore, c, d, e, f, g) {
+    builder.prep(8, 2656);
+    for (let i = 1; i >= 0; --i) {
+      builder.writeInt64(BigInt(g?.[i] ?? 0));
     }
-    __init(i, bb) {
-        this.bb_pos = i;
-        this.bb = bb;
-        return this;
+    for (let i = 1; i >= 0; --i) {
+      const item = f?.[i];
+      if (item instanceof OuterStructT) {
+        item.pack(builder);
+        continue;
+      }
+      OuterStruct.createOuterStruct(
+          builder, item?.a, item?.b, (item?.cUnderscore?.a ?? 0),
+          (item?.cUnderscore?.b ?? []), (item?.cUnderscore?.c ?? 0),
+          (item?.cUnderscore?.dUnderscore ?? BigInt(0)), item?.d,
+          (item?.e?.a ?? 0), (item?.e?.b ?? []), (item?.e?.c ?? 0),
+          (item?.e?.dUnderscore ?? BigInt(0)), item?.f);
     }
-    aUnderscore() {
-        return this.bb.readFloat32(this.bb_pos);
+    builder.pad(4);
+    builder.writeInt32(e);
+    for (let i = 1; i >= 0; --i) {
+      const item = d?.[i];
+      if (item instanceof NestedStructT) {
+        item.pack(builder);
+        continue;
+      }
+      NestedStruct.createNestedStruct(
+          builder, item?.a, item?.b, item?.cUnderscore, item?.dOuter, item?.e);
     }
-    bUnderscore(index) {
-        return this.bb.readInt32(this.bb_pos + 4 + index * 4);
-    }
-    c() {
-        return this.bb.readInt8(this.bb_pos + 64);
-    }
-    d(index, obj) {
-        return (obj || new NestedStruct()).__init(this.bb_pos + 72 + index * 1072, this.bb);
-    }
-    e() {
-        return this.bb.readInt32(this.bb_pos + 2216);
-    }
-    f(index, obj) {
-        return (obj || new OuterStruct()).__init(this.bb_pos + 2224 + index * 208, this.bb);
-    }
-    g(index) {
-        return this.bb.readInt64(this.bb_pos + 2640 + index * 8);
-    }
-    static getFullyQualifiedName() {
-        return 'MyGame.Example.ArrayStruct';
-    }
-    static sizeOf() {
-        return 2656;
-    }
-    static createArrayStruct(builder, a_underscore, b_underscore, c, d, e, f, g) {
-        builder.prep(8, 2656);
-        for (let i = 1; i >= 0; --i) {
-            builder.writeInt64(BigInt(g?.[i] ?? 0));
-        }
-        for (let i = 1; i >= 0; --i) {
-            const item = f?.[i];
-            if (item instanceof OuterStructT) {
-                item.pack(builder);
-                continue;
-            }
-            OuterStruct.createOuterStruct(builder, item?.a, item?.b, (item?.cUnderscore?.a ?? 0), (item?.cUnderscore?.b ?? []), (item?.cUnderscore?.c ?? 0), (item?.cUnderscore?.dUnderscore ?? BigInt(0)), item?.d, (item?.e?.a ?? 0), (item?.e?.b ?? []), (item?.e?.c ?? 0), (item?.e?.dUnderscore ?? BigInt(0)), item?.f);
-        }
-        builder.pad(4);
-        builder.writeInt32(e);
-        for (let i = 1; i >= 0; --i) {
-            const item = d?.[i];
-            if (item instanceof NestedStructT) {
-                item.pack(builder);
-                continue;
-            }
-            NestedStruct.createNestedStruct(builder, item?.a, item?.b, item?.cUnderscore, item?.dOuter, item?.e);
-        }
-        builder.pad(7);
-        builder.writeInt8(c);
-        for (let i = 14; i >= 0; --i) {
-            builder.writeInt32((b_underscore?.[i] ?? 0));
-        }
-        builder.writeFloat32(a_underscore);
-        return builder.offset();
-    }
-    unpack() {
-        return new ArrayStructT(this.aUnderscore(), this.bb.createScalarList(this.bUnderscore.bind(this), 15), this.c(), this.bb.createObjList(this.d.bind(this), 2), this.e(), this.bb.createObjList(this.f.bind(this), 2), this.bb.createScalarList(this.g.bind(this), 2));
-    }
-    unpackTo(_o) {
-        _o.aUnderscore = this.aUnderscore();
-        _o.bUnderscore = this.bb.createScalarList(this.bUnderscore.bind(this), 15);
-        _o.c = this.c();
-        _o.d = this.bb.createObjList(this.d.bind(this), 2);
-        _o.e = this.e();
-        _o.f = this.bb.createObjList(this.f.bind(this), 2);
-        _o.g = this.bb.createScalarList(this.g.bind(this), 2);
+    builder.pad(7);
+    builder.writeInt8(c);
+    for (let i = 14; i >= 0; --i) {
+      builder.writeInt32((b_underscore?.[i] ?? 0));
     }
+    builder.writeFloat32(a_underscore);
+    return builder.offset();
+  }
+  unpack() {
+    return new ArrayStructT(
+        this.aUnderscore(),
+        this.bb.createScalarList(this.bUnderscore.bind(this), 15), this.c(),
+        this.bb.createObjList(this.d.bind(this), 2), this.e(),
+        this.bb.createObjList(this.f.bind(this), 2),
+        this.bb.createScalarList(this.g.bind(this), 2));
+  }
+  unpackTo(_o) {
+    _o.aUnderscore = this.aUnderscore();
+    _o.bUnderscore = this.bb.createScalarList(this.bUnderscore.bind(this), 15);
+    _o.c = this.c();
+    _o.d = this.bb.createObjList(this.d.bind(this), 2);
+    _o.e = this.e();
+    _o.f = this.bb.createObjList(this.f.bind(this), 2);
+    _o.g = this.bb.createScalarList(this.g.bind(this), 2);
+  }
 }
 export class ArrayStructT {
-    constructor(aUnderscore = 0.0, bUnderscore = [], c = 0, d = [], e = 0, f = [], g = []) {
-        this.aUnderscore = aUnderscore;
-        this.bUnderscore = bUnderscore;
-        this.c = c;
-        this.d = d;
-        this.e = e;
-        this.f = f;
-        this.g = g;
-    }
-    pack(builder) {
-        return ArrayStruct.createArrayStruct(builder, this.aUnderscore, this.bUnderscore, this.c, this.d, this.e, this.f, this.g);
-    }
+  constructor(
+      aUnderscore = 0.0, bUnderscore = [], c = 0, d = [], e = 0, f = [],
+      g = []) {
+    this.aUnderscore = aUnderscore;
+    this.bUnderscore = bUnderscore;
+    this.c = c;
+    this.d = d;
+    this.e = e;
+    this.f = f;
+    this.g = g;
+  }
+  pack(builder) {
+    return ArrayStruct.createArrayStruct(
+        builder, this.aUnderscore, this.bUnderscore, this.c, this.d, this.e,
+        this.f, this.g);
+  }
 }

tests/ts/arrays_test_complex/my-game/example/array-struct.ts

@@ -4,165 +4,191 @@
 
 import * as flatbuffers from 'flatbuffers';
 
-import { NestedStruct, NestedStructT } from './nested-struct.js';
-import { OuterStruct, OuterStructT } from './outer-struct.js';
+import {
+  NestedStruct,
+  NestedStructT,
+} from '../../my-game/example/nested-struct.js';
+import {OuterStruct, OuterStructT} from '../../my-game/example/outer-struct.js';
 
+export class ArrayStruct
+  implements flatbuffers.IUnpackableObject<ArrayStructT>
+{
+  bb: flatbuffers.ByteBuffer | null = null;
+  bb_pos = 0;
+  __init(i: number, bb: flatbuffers.ByteBuffer): ArrayStruct {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
 
-export class ArrayStruct implements flatbuffers.IUnpackableObject<ArrayStructT> {
-  bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
-  __init(i:number, bb:flatbuffers.ByteBuffer):ArrayStruct {
-  this.bb_pos = i;
-  this.bb = bb;
-  return this;
-}
+  aUnderscore(): number {
+    return this.bb!.readFloat32(this.bb_pos);
+  }
 
-aUnderscore():number {
-  return this.bb!.readFloat32(this.bb_pos);
-}
-
-bUnderscore(index: number):number|null {
+  bUnderscore(index: number): number | null {
     return this.bb!.readInt32(this.bb_pos + 4 + index * 4);
-}
+  }
 
-c():number {
-  return this.bb!.readInt8(this.bb_pos + 64);
-}
+  c(): number {
+    return this.bb!.readInt8(this.bb_pos + 64);
+  }
 
-d(index: number, obj?:NestedStruct):NestedStruct|null {
-    return (obj || new NestedStruct()).__init(this.bb_pos + 72 + index * 1072, this.bb!);
-}
+  d(index: number, obj?: NestedStruct): NestedStruct | null {
+    return (obj || new NestedStruct()).__init(
+      this.bb_pos + 72 + index * 1072,
+      this.bb!,
+    );
+  }
 
-e():number {
-  return this.bb!.readInt32(this.bb_pos + 2216);
-}
+  e(): number {
+    return this.bb!.readInt32(this.bb_pos + 2216);
+  }
 
-f(index: number, obj?:OuterStruct):OuterStruct|null {
-    return (obj || new OuterStruct()).__init(this.bb_pos + 2224 + index * 208, this.bb!);
-}
+  f(index: number, obj?: OuterStruct): OuterStruct | null {
+    return (obj || new OuterStruct()).__init(
+      this.bb_pos + 2224 + index * 208,
+      this.bb!,
+    );
+  }
 
-g(index: number):bigint|null {
+  g(index: number): bigint | null {
     return this.bb!.readInt64(this.bb_pos + 2640 + index * 8);
-}
-
-static getFullyQualifiedName(): "MyGame.Example.ArrayStruct" {
-  return 'MyGame.Example.ArrayStruct';
-}
-
-static sizeOf():number {
-  return 2656;
-}
-
-static createArrayStruct(builder:flatbuffers.Builder, a_underscore: number, b_underscore: number[], c: number, d: (any|NestedStructT)[], e: number, f: (any|OuterStructT)[], g: bigint[]):flatbuffers.Offset {
-  builder.prep(8, 2656);
-
-  for (let i = 1; i >= 0; --i) {
-    builder.writeInt64(BigInt(g?.[i] ?? 0));
   }
 
+  static getFullyQualifiedName(): string {
+    return 'MyGame.Example.ArrayStruct';
+  }
 
-  for (let i = 1; i >= 0; --i) {
-    const item = f?.[i];
+  static sizeOf(): number {
+    return 2656;
+  }
 
-    if (item instanceof OuterStructT) {
-      item.pack(builder);
-      continue;
+  static createArrayStruct(
+    builder: flatbuffers.Builder,
+    a_underscore: number,
+    b_underscore: number[] | null,
+    c: number,
+    d: (any | NestedStructT)[] | null,
+    e: number,
+    f: (any | OuterStructT)[] | null,
+    g: bigint[] | null,
+  ): flatbuffers.Offset {
+    builder.prep(8, 2656);
+
+    for (let i = 1; i >= 0; --i) {
+      builder.writeInt64(BigInt(g?.[i] ?? 0));
     }
 
-    OuterStruct.createOuterStruct(builder,
-    item?.a,
-    item?.b,
-    (item?.cUnderscore?.a ?? 0),
-    (item?.cUnderscore?.b ?? []),
-    (item?.cUnderscore?.c ?? 0),
-    (item?.cUnderscore?.dUnderscore ?? BigInt(0)),
-    item?.d,
-    (item?.e?.a ?? 0),
-    (item?.e?.b ?? []),
-    (item?.e?.c ?? 0),
-    (item?.e?.dUnderscore ?? BigInt(0)),
-    item?.f
+    for (let i = 1; i >= 0; --i) {
+      const item = f?.[i];
+
+      if (item instanceof OuterStructT) {
+        item.pack(builder);
+        continue;
+      }
+
+      OuterStruct.createOuterStruct(
+        builder,
+        item?.a,
+        item?.b,
+        item?.cUnderscore?.a ?? 0,
+        item?.cUnderscore?.b ?? [],
+        item?.cUnderscore?.c ?? 0,
+        item?.cUnderscore?.dUnderscore ?? BigInt(0),
+        item?.d,
+        item?.e?.a ?? 0,
+        item?.e?.b ?? [],
+        item?.e?.c ?? 0,
+        item?.e?.dUnderscore ?? BigInt(0),
+        item?.f,
+      );
+    }
+
+    builder.pad(4);
+    builder.writeInt32(e);
+
+    for (let i = 1; i >= 0; --i) {
+      const item = d?.[i];
+
+      if (item instanceof NestedStructT) {
+        item.pack(builder);
+        continue;
+      }
+
+      NestedStruct.createNestedStruct(
+        builder,
+        item?.a,
+        item?.b,
+        item?.cUnderscore,
+        item?.dOuter,
+        item?.e,
+      );
+    }
+
+    builder.pad(7);
+    builder.writeInt8(c);
+
+    for (let i = 14; i >= 0; --i) {
+      builder.writeInt32(b_underscore?.[i] ?? 0);
+    }
+
+    builder.writeFloat32(a_underscore);
+    return builder.offset();
+  }
+
+  unpack(): ArrayStructT {
+    return new ArrayStructT(
+      this.aUnderscore(),
+      this.bb!.createScalarList<number>(this.bUnderscore.bind(this), 15),
+      this.c(),
+      this.bb!.createObjList<NestedStruct, NestedStructT>(this.d.bind(this), 2),
+      this.e(),
+      this.bb!.createObjList<OuterStruct, OuterStructT>(this.f.bind(this), 2),
+      this.bb!.createScalarList<bigint>(this.g.bind(this), 2),
     );
   }
 
-  builder.pad(4);
-  builder.writeInt32(e);
-
-  for (let i = 1; i >= 0; --i) {
-    const item = d?.[i];
-
-    if (item instanceof NestedStructT) {
-      item.pack(builder);
-      continue;
-    }
-
-    NestedStruct.createNestedStruct(builder,
-    item?.a,
-    item?.b,
-    item?.cUnderscore,
-    item?.dOuter,
-    item?.e
+  unpackTo(_o: ArrayStructT): void {
+    _o.aUnderscore = this.aUnderscore();
+    _o.bUnderscore = this.bb!.createScalarList<number>(
+      this.bUnderscore.bind(this),
+      15,
     );
+    _o.c = this.c();
+    _o.d = this.bb!.createObjList<NestedStruct, NestedStructT>(
+      this.d.bind(this),
+      2,
+    );
+    _o.e = this.e();
+    _o.f = this.bb!.createObjList<OuterStruct, OuterStructT>(
+      this.f.bind(this),
+      2,
+    );
+    _o.g = this.bb!.createScalarList<bigint>(this.g.bind(this), 2);
   }
-
-  builder.pad(7);
-  builder.writeInt8(c);
-
-  for (let i = 14; i >= 0; --i) {
-    builder.writeInt32((b_underscore?.[i] ?? 0));
-
-  }
-
-  builder.writeFloat32(a_underscore);
-  return builder.offset();
-}
-
-
-unpack(): ArrayStructT {
-  return new ArrayStructT(
-    this.aUnderscore(),
-    this.bb!.createScalarList<number>(this.bUnderscore.bind(this), 15),
-    this.c(),
-    this.bb!.createObjList<NestedStruct, NestedStructT>(this.d.bind(this), 2),
-    this.e(),
-    this.bb!.createObjList<OuterStruct, OuterStructT>(this.f.bind(this), 2),
-    this.bb!.createScalarList<bigint>(this.g.bind(this), 2)
-  );
-}
-
-
-unpackTo(_o: ArrayStructT): void {
-  _o.aUnderscore = this.aUnderscore();
-  _o.bUnderscore = this.bb!.createScalarList<number>(this.bUnderscore.bind(this), 15);
-  _o.c = this.c();
-  _o.d = this.bb!.createObjList<NestedStruct, NestedStructT>(this.d.bind(this), 2);
-  _o.e = this.e();
-  _o.f = this.bb!.createObjList<OuterStruct, OuterStructT>(this.f.bind(this), 2);
-  _o.g = this.bb!.createScalarList<bigint>(this.g.bind(this), 2);
-}
 }
 
 export class ArrayStructT implements flatbuffers.IGeneratedObject {
-constructor(
-  public aUnderscore: number = 0.0,
-  public bUnderscore: (number)[] = [],
-  public c: number = 0,
-  public d: (NestedStructT)[] = [],
-  public e: number = 0,
-  public f: (OuterStructT)[] = [],
-  public g: (bigint)[] = []
-){}
+  constructor(
+    public aUnderscore: number = 0.0,
+    public bUnderscore: number[] = [],
+    public c: number = 0,
+    public d: NestedStructT[] = [],
+    public e: number = 0,
+    public f: OuterStructT[] = [],
+    public g: bigint[] = [],
+  ) {}
 
-
-pack(builder:flatbuffers.Builder): flatbuffers.Offset {
-  return ArrayStruct.createArrayStruct(builder,
-    this.aUnderscore,
-    this.bUnderscore,
-    this.c,
-    this.d,
-    this.e,
-    this.f,
-    this.g
-  );
-}
+  pack(builder: flatbuffers.Builder): flatbuffers.Offset {
+    return ArrayStruct.createArrayStruct(
+      builder,
+      this.aUnderscore,
+      this.bUnderscore,
+      this.c,
+      this.d,
+      this.e,
+      this.f,
+      this.g,
+    );
+  }
 }

tests/ts/arrays_test_complex/my-game/example/array-table.d.ts

@@ -1,28 +1,48 @@
 import * as flatbuffers from 'flatbuffers';
-import { ArrayStruct, ArrayStructT } from './array-struct.js';
-export declare class ArrayTable implements flatbuffers.IUnpackableObject<ArrayTableT> {
-    bb: flatbuffers.ByteBuffer | null;
-    bb_pos: number;
-    __init(i: number, bb: flatbuffers.ByteBuffer): ArrayTable;
-    static getRootAsArrayTable(bb: flatbuffers.ByteBuffer, obj?: ArrayTable): ArrayTable;
-    static getSizePrefixedRootAsArrayTable(bb: flatbuffers.ByteBuffer, obj?: ArrayTable): ArrayTable;
-    static bufferHasIdentifier(bb: flatbuffers.ByteBuffer): boolean;
-    a(): string | null;
-    a(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
-    cUnderscore(obj?: ArrayStruct): ArrayStruct | null;
-    static getFullyQualifiedName(): "MyGame.Example.ArrayTable";
-    static startArrayTable(builder: flatbuffers.Builder): void;
-    static addA(builder: flatbuffers.Builder, aOffset: flatbuffers.Offset): void;
-    static addCUnderscore(builder: flatbuffers.Builder, cUnderscoreOffset: flatbuffers.Offset): void;
-    static endArrayTable(builder: flatbuffers.Builder): flatbuffers.Offset;
-    static finishArrayTableBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
-    static finishSizePrefixedArrayTableBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
-    unpack(): ArrayTableT;
-    unpackTo(_o: ArrayTableT): void;
+import {ArrayStruct, ArrayStructT} from '../../my-game/example/array-struct.js';
+export declare class ArrayTable
+  implements flatbuffers.IUnpackableObject<ArrayTableT>
+{
+  bb: flatbuffers.ByteBuffer | null;
+  bb_pos: number;
+  __init(i: number, bb: flatbuffers.ByteBuffer): ArrayTable;
+  static getRootAsArrayTable(
+    bb: flatbuffers.ByteBuffer,
+    obj?: ArrayTable,
+  ): ArrayTable;
+  static getSizePrefixedRootAsArrayTable(
+    bb: flatbuffers.ByteBuffer,
+    obj?: ArrayTable,
+  ): ArrayTable;
+  static bufferHasIdentifier(bb: flatbuffers.ByteBuffer): boolean;
+  a(): string | null;
+  a(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+  cUnderscore(obj?: ArrayStruct): ArrayStruct | null;
+  static getFullyQualifiedName(): string;
+  static startArrayTable(builder: flatbuffers.Builder): void;
+  static addA(builder: flatbuffers.Builder, aOffset: flatbuffers.Offset): void;
+  static addCUnderscore(
+    builder: flatbuffers.Builder,
+    cUnderscoreOffset: flatbuffers.Offset,
+  ): void;
+  static endArrayTable(builder: flatbuffers.Builder): flatbuffers.Offset;
+  static finishArrayTableBuffer(
+    builder: flatbuffers.Builder,
+    offset: flatbuffers.Offset,
+  ): void;
+  static finishSizePrefixedArrayTableBuffer(
+    builder: flatbuffers.Builder,
+    offset: flatbuffers.Offset,
+  ): void;
+  unpack(): ArrayTableT;
+  unpackTo(_o: ArrayTableT): void;
 }
 export declare class ArrayTableT implements flatbuffers.IGeneratedObject {
-    a: string | Uint8Array | null;
-    cUnderscore: ArrayStructT | null;
-    constructor(a?: string | Uint8Array | null, cUnderscore?: ArrayStructT | null);
-    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+  a: string | Uint8Array | null;
+  cUnderscore: ArrayStructT | null;
+  constructor(
+    a?: string | Uint8Array | null,
+    cUnderscore?: ArrayStructT | null,
+  );
+  pack(builder: flatbuffers.Builder): flatbuffers.Offset;
 }

tests/ts/arrays_test_complex/my-game/example/array-table.js

@@ -1,75 +1,88 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any,
+ * @typescript-eslint/no-non-null-assertion */
 import * as flatbuffers from 'flatbuffers';
-import { ArrayStruct } from './array-struct.js';
+
+import {ArrayStruct} from '../../my-game/example/array-struct.js';
+
 export class ArrayTable {
-    constructor() {
-        this.bb = null;
-        this.bb_pos = 0;
-    }
-    __init(i, bb) {
-        this.bb_pos = i;
-        this.bb = bb;
-        return this;
-    }
-    static getRootAsArrayTable(bb, obj) {
-        return (obj || new ArrayTable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
-    }
-    static getSizePrefixedRootAsArrayTable(bb, obj) {
-        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
-        return (obj || new ArrayTable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
-    }
-    static bufferHasIdentifier(bb) {
-        return bb.__has_identifier('RHUB');
-    }
-    a(optionalEncoding) {
-        const offset = this.bb.__offset(this.bb_pos, 4);
-        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
-    }
-    cUnderscore(obj) {
-        const offset = this.bb.__offset(this.bb_pos, 6);
-        return offset ? (obj || new ArrayStruct()).__init(this.bb_pos + offset, this.bb) : null;
-    }
-    static getFullyQualifiedName() {
-        return 'MyGame.Example.ArrayTable';
-    }
-    static startArrayTable(builder) {
-        builder.startObject(2);
-    }
-    static addA(builder, aOffset) {
-        builder.addFieldOffset(0, aOffset, 0);
-    }
-    static addCUnderscore(builder, cUnderscoreOffset) {
-        builder.addFieldStruct(1, cUnderscoreOffset, 0);
-    }
-    static endArrayTable(builder) {
-        const offset = builder.endObject();
-        return offset;
-    }
-    static finishArrayTableBuffer(builder, offset) {
-        builder.finish(offset, 'RHUB');
-    }
-    static finishSizePrefixedArrayTableBuffer(builder, offset) {
-        builder.finish(offset, 'RHUB', true);
-    }
-    unpack() {
-        return new ArrayTableT(this.a(), (this.cUnderscore() !== null ? this.cUnderscore().unpack() : null));
-    }
-    unpackTo(_o) {
-        _o.a = this.a();
-        _o.cUnderscore = (this.cUnderscore() !== null ? this.cUnderscore().unpack() : null);
-    }
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  static getRootAsArrayTable(bb, obj) {
+    return (obj || new ArrayTable())
+        .__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  static getSizePrefixedRootAsArrayTable(bb, obj) {
+    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+    return (obj || new ArrayTable())
+        .__init(bb.readInt32(bb.position()) + bb.position(), bb);
+  }
+  static bufferHasIdentifier(bb) {
+    return bb.__has_identifier('RHUB');
+  }
+  a(optionalEncoding) {
+    const offset = this.bb.__offset(this.bb_pos, 4);
+    return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) :
+                    null;
+  }
+  cUnderscore(obj) {
+    const offset = this.bb.__offset(this.bb_pos, 6);
+    return offset ?
+        (obj || new ArrayStruct()).__init(this.bb_pos + offset, this.bb) :
+        null;
+  }
+  static getFullyQualifiedName() {
+    return 'MyGame.Example.ArrayTable';
+  }
+  static startArrayTable(builder) {
+    builder.startObject(2);
+  }
+  static addA(builder, aOffset) {
+    builder.addFieldOffset(0, aOffset, 0);
+  }
+  static addCUnderscore(builder, cUnderscoreOffset) {
+    builder.addFieldStruct(1, cUnderscoreOffset, 0);
+  }
+  static endArrayTable(builder) {
+    const offset = builder.endObject();
+    return offset;
+  }
+  static finishArrayTableBuffer(builder, offset) {
+    builder.finish(offset, 'RHUB');
+  }
+  static finishSizePrefixedArrayTableBuffer(builder, offset) {
+    builder.finish(offset, 'RHUB', true);
+  }
+  unpack() {
+    return new ArrayTableT(
+        this.a(),
+        (this.cUnderscore() !== null ? this.cUnderscore().unpack() : null));
+  }
+  unpackTo(_o) {
+    _o.a = this.a();
+    _o.cUnderscore =
+        (this.cUnderscore() !== null ? this.cUnderscore().unpack() : null);
+  }
 }
 export class ArrayTableT {
-    constructor(a = null, cUnderscore = null) {
-        this.a = a;
-        this.cUnderscore = cUnderscore;
-    }
-    pack(builder) {
-        const a = (this.a !== null ? builder.createString(this.a) : 0);
-        ArrayTable.startArrayTable(builder);
-        ArrayTable.addA(builder, a);
-        ArrayTable.addCUnderscore(builder, (this.cUnderscore !== null ? this.cUnderscore.pack(builder) : 0));
-        return ArrayTable.endArrayTable(builder);
-    }
+  constructor(a = null, cUnderscore = null) {
+    this.a = a;
+    this.cUnderscore = cUnderscore;
+  }
+  pack(builder) {
+    const a = (this.a !== null ? builder.createString(this.a) : 0);
+    ArrayTable.startArrayTable(builder);
+    ArrayTable.addA(builder, a);
+    ArrayTable.addCUnderscore(
+        builder,
+        (this.cUnderscore !== null ? this.cUnderscore.pack(builder) : 0));
+    return ArrayTable.endArrayTable(builder);
+  }
 }

tests/ts/arrays_test_complex/my-game/example/array-table.ts

@@ -4,101 +4,126 @@
 
 import * as flatbuffers from 'flatbuffers';
 
-import { ArrayStruct, ArrayStructT } from './array-struct.js';
-
+import {ArrayStruct, ArrayStructT} from '../../my-game/example/array-struct.js';
 
 export class ArrayTable implements flatbuffers.IUnpackableObject<ArrayTableT> {
-  bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
-  __init(i:number, bb:flatbuffers.ByteBuffer):ArrayTable {
-  this.bb_pos = i;
-  this.bb = bb;
-  return this;
-}
+  bb: flatbuffers.ByteBuffer | null = null;
+  bb_pos = 0;
+  __init(i: number, bb: flatbuffers.ByteBuffer): ArrayTable {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
 
-static getRootAsArrayTable(bb:flatbuffers.ByteBuffer, obj?:ArrayTable):ArrayTable {
-  return (obj || new ArrayTable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
-}
+  static getRootAsArrayTable(
+    bb: flatbuffers.ByteBuffer,
+    obj?: ArrayTable,
+  ): ArrayTable {
+    return (obj || new ArrayTable()).__init(
+      bb.readInt32(bb.position()) + bb.position(),
+      bb,
+    );
+  }
 
-static getSizePrefixedRootAsArrayTable(bb:flatbuffers.ByteBuffer, obj?:ArrayTable):ArrayTable {
-  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
-  return (obj || new ArrayTable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
-}
+  static getSizePrefixedRootAsArrayTable(
+    bb: flatbuffers.ByteBuffer,
+    obj?: ArrayTable,
+  ): ArrayTable {
+    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+    return (obj || new ArrayTable()).__init(
+      bb.readInt32(bb.position()) + bb.position(),
+      bb,
+    );
+  }
 
-static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean {
-  return bb.__has_identifier('RHUB');
-}
+  static bufferHasIdentifier(bb: flatbuffers.ByteBuffer): boolean {
+    return bb.__has_identifier('RHUB');
+  }
 
-a():string|null
-a(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
-a(optionalEncoding?:any):string|Uint8Array|null {
-  const offset = this.bb!.__offset(this.bb_pos, 4);
-  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
-}
+  a(): string | null;
+  a(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+  a(optionalEncoding?: any): string | Uint8Array | null {
+    const offset = this.bb!.__offset(this.bb_pos, 4);
+    return offset
+      ? this.bb!.__string(this.bb_pos + offset, optionalEncoding)
+      : null;
+  }
 
-cUnderscore(obj?:ArrayStruct):ArrayStruct|null {
-  const offset = this.bb!.__offset(this.bb_pos, 6);
-  return offset ? (obj || new ArrayStruct()).__init(this.bb_pos + offset, this.bb!) : null;
-}
+  cUnderscore(obj?: ArrayStruct): ArrayStruct | null {
+    const offset = this.bb!.__offset(this.bb_pos, 6);
+    return offset
+      ? (obj || new ArrayStruct()).__init(this.bb_pos + offset, this.bb!)
+      : null;
+  }
 
-static getFullyQualifiedName(): "MyGame.Example.ArrayTable" {
-  return 'MyGame.Example.ArrayTable';
-}
+  static getFullyQualifiedName(): string {
+    return 'MyGame.Example.ArrayTable';
+  }
 
-static startArrayTable(builder:flatbuffers.Builder):void {
-  builder.startObject(2);
-}
+  static startArrayTable(builder: flatbuffers.Builder) {
+    builder.startObject(2);
+  }
 
-static addA(builder:flatbuffers.Builder, aOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(0, aOffset, 0);
-}
+  static addA(builder: flatbuffers.Builder, aOffset: flatbuffers.Offset) {
+    builder.addFieldOffset(0, aOffset, 0);
+  }
 
-static addCUnderscore(builder:flatbuffers.Builder, cUnderscoreOffset:flatbuffers.Offset):void {
-  builder.addFieldStruct(1, cUnderscoreOffset, 0);
-}
+  static addCUnderscore(
+    builder: flatbuffers.Builder,
+    cUnderscoreOffset: flatbuffers.Offset,
+  ) {
+    builder.addFieldStruct(1, cUnderscoreOffset, 0);
+  }
 
-static endArrayTable(builder:flatbuffers.Builder):flatbuffers.Offset {
-  const offset = builder.endObject();
-  return offset;
-}
+  static endArrayTable(builder: flatbuffers.Builder): flatbuffers.Offset {
+    const offset = builder.endObject();
+    return offset;
+  }
 
-static finishArrayTableBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset):void {
-  builder.finish(offset, 'RHUB');
-}
+  static finishArrayTableBuffer(
+    builder: flatbuffers.Builder,
+    offset: flatbuffers.Offset,
+  ) {
+    builder.finish(offset, 'RHUB');
+  }
 
-static finishSizePrefixedArrayTableBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset):void {
-  builder.finish(offset, 'RHUB', true);
-}
+  static finishSizePrefixedArrayTableBuffer(
+    builder: flatbuffers.Builder,
+    offset: flatbuffers.Offset,
+  ) {
+    builder.finish(offset, 'RHUB', true);
+  }
 
+  unpack(): ArrayTableT {
+    return new ArrayTableT(
+      this.a(),
+      this.cUnderscore() !== null ? this.cUnderscore()!.unpack() : null,
+    );
+  }
 
-unpack(): ArrayTableT {
-  return new ArrayTableT(
-    this.a(),
-    (this.cUnderscore() !== null ? this.cUnderscore()!.unpack() : null)
-  );
-}
-
-
-unpackTo(_o: ArrayTableT): void {
-  _o.a = this.a();
-  _o.cUnderscore = (this.cUnderscore() !== null ? this.cUnderscore()!.unpack() : null);
-}
+  unpackTo(_o: ArrayTableT): void {
+    _o.a = this.a();
+    _o.cUnderscore =
+      this.cUnderscore() !== null ? this.cUnderscore()!.unpack() : null;
+  }
 }
 
 export class ArrayTableT implements flatbuffers.IGeneratedObject {
-constructor(
-  public a: string|Uint8Array|null = null,
-  public cUnderscore: ArrayStructT|null = null
-){}
+  constructor(
+    public a: string | Uint8Array | null = null,
+    public cUnderscore: ArrayStructT | null = null,
+  ) {}
 
+  pack(builder: flatbuffers.Builder): flatbuffers.Offset {
+    const a = this.a !== null ? builder.createString(this.a!) : 0;
 
-pack(builder:flatbuffers.Builder): flatbuffers.Offset {
-  const a = (this.a !== null ? builder.createString(this.a!) : 0);
+    ArrayTable.startArrayTable(builder);
+    ArrayTable.addA(builder, a);
+    ArrayTable.addCUnderscore(
+      builder,
+      this.cUnderscore !== null ? this.cUnderscore!.pack(builder) : 0,
+    );
 
-  ArrayTable.startArrayTable(builder);
-  ArrayTable.addA(builder, a);
-  ArrayTable.addCUnderscore(builder, (this.cUnderscore !== null ? this.cUnderscore!.pack(builder) : 0));
-
-  return ArrayTable.endArrayTable(builder);
-}
+    return ArrayTable.endArrayTable(builder);
+  }
 }

tests/ts/arrays_test_complex/my-game/example/inner-struct.d.ts

@@ -1,23 +1,31 @@
 import * as flatbuffers from 'flatbuffers';
-export declare class InnerStruct implements flatbuffers.IUnpackableObject<InnerStructT> {
-    bb: flatbuffers.ByteBuffer | null;
-    bb_pos: number;
-    __init(i: number, bb: flatbuffers.ByteBuffer): InnerStruct;
-    a(): number;
-    b(index: number): number | null;
-    c(): number;
-    dUnderscore(): bigint;
-    static getFullyQualifiedName(): "MyGame.Example.InnerStruct";
-    static sizeOf(): number;
-    static createInnerStruct(builder: flatbuffers.Builder, a: number, b: number[], c: number, d_underscore: bigint): flatbuffers.Offset;
-    unpack(): InnerStructT;
-    unpackTo(_o: InnerStructT): void;
+export declare class InnerStruct
+  implements flatbuffers.IUnpackableObject<InnerStructT>
+{
+  bb: flatbuffers.ByteBuffer | null;
+  bb_pos: number;
+  __init(i: number, bb: flatbuffers.ByteBuffer): InnerStruct;
+  a(): number;
+  b(index: number): number | null;
+  c(): number;
+  dUnderscore(): bigint;
+  static getFullyQualifiedName(): string;
+  static sizeOf(): number;
+  static createInnerStruct(
+    builder: flatbuffers.Builder,
+    a: number,
+    b: number[] | null,
+    c: number,
+    d_underscore: bigint,
+  ): flatbuffers.Offset;
+  unpack(): InnerStructT;
+  unpackTo(_o: InnerStructT): void;
 }
 export declare class InnerStructT implements flatbuffers.IGeneratedObject {
-    a: number;
-    b: (number)[];
-    c: number;
-    dUnderscore: bigint;
-    constructor(a?: number, b?: (number)[], c?: number, dUnderscore?: bigint);
-    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+  a: number;
+  b: number[];
+  c: number;
+  dUnderscore: bigint;
+  constructor(a?: number, b?: number[], c?: number, dUnderscore?: bigint);
+  pack(builder: flatbuffers.Builder): flatbuffers.Offset;
 }

tests/ts/arrays_test_complex/my-game/example/inner-struct.js

@@ -1,61 +1,64 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 export class InnerStruct {
-    constructor() {
-        this.bb = null;
-        this.bb_pos = 0;
-    }
-    __init(i, bb) {
-        this.bb_pos = i;
-        this.bb = bb;
-        return this;
-    }
-    a() {
-        return this.bb.readFloat64(this.bb_pos);
-    }
-    b(index) {
-        return this.bb.readUint8(this.bb_pos + 8 + index);
-    }
-    c() {
-        return this.bb.readInt8(this.bb_pos + 21);
-    }
-    dUnderscore() {
-        return this.bb.readInt64(this.bb_pos + 24);
-    }
-    static getFullyQualifiedName() {
-        return 'MyGame.Example.InnerStruct';
-    }
-    static sizeOf() {
-        return 32;
-    }
-    static createInnerStruct(builder, a, b, c, d_underscore) {
-        builder.prep(8, 32);
-        builder.writeInt64(BigInt(d_underscore ?? 0));
-        builder.pad(2);
-        builder.writeInt8(c);
-        for (let i = 12; i >= 0; --i) {
-            builder.writeInt8((b?.[i] ?? 0));
-        }
-        builder.writeFloat64(a);
-        return builder.offset();
-    }
-    unpack() {
-        return new InnerStructT(this.a(), this.bb.createScalarList(this.b.bind(this), 13), this.c(), this.dUnderscore());
-    }
-    unpackTo(_o) {
-        _o.a = this.a();
-        _o.b = this.bb.createScalarList(this.b.bind(this), 13);
-        _o.c = this.c();
-        _o.dUnderscore = this.dUnderscore();
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  a() {
+    return this.bb.readFloat64(this.bb_pos);
+  }
+  b(index) {
+    return this.bb.readUint8(this.bb_pos + 8 + index);
+  }
+  c() {
+    return this.bb.readInt8(this.bb_pos + 21);
+  }
+  dUnderscore() {
+    return this.bb.readInt64(this.bb_pos + 24);
+  }
+  static getFullyQualifiedName() {
+    return 'MyGame.Example.InnerStruct';
+  }
+  static sizeOf() {
+    return 32;
+  }
+  static createInnerStruct(builder, a, b, c, d_underscore) {
+    builder.prep(8, 32);
+    builder.writeInt64(BigInt(d_underscore ?? 0));
+    builder.pad(2);
+    builder.writeInt8(c);
+    for (let i = 12; i >= 0; --i) {
+      builder.writeInt8((b?.[i] ?? 0));
     }
+    builder.writeFloat64(a);
+    return builder.offset();
+  }
+  unpack() {
+    return new InnerStructT(
+        this.a(), this.bb.createScalarList(this.b.bind(this), 13), this.c(),
+        this.dUnderscore());
+  }
+  unpackTo(_o) {
+    _o.a = this.a();
+    _o.b = this.bb.createScalarList(this.b.bind(this), 13);
+    _o.c = this.c();
+    _o.dUnderscore = this.dUnderscore();
+  }
 }
 export class InnerStructT {
-    constructor(a = 0.0, b = [], c = 0, dUnderscore = BigInt('0')) {
-        this.a = a;
-        this.b = b;
-        this.c = c;
-        this.dUnderscore = dUnderscore;
-    }
-    pack(builder) {
-        return InnerStruct.createInnerStruct(builder, this.a, this.b, this.c, this.dUnderscore);
-    }
+  constructor(a = 0.0, b = [], c = 0, dUnderscore = BigInt('0')) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+    this.dUnderscore = dUnderscore;
+  }
+  pack(builder) {
+    return InnerStruct.createInnerStruct(
+        builder, this.a, this.b, this.c, this.dUnderscore);
+  }
 }

tests/ts/arrays_test_complex/my-game/example/inner-struct.ts

@@ -4,90 +4,93 @@
 
 import * as flatbuffers from 'flatbuffers';
 
-
-
-export class InnerStruct implements flatbuffers.IUnpackableObject<InnerStructT> {
-  bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
-  __init(i:number, bb:flatbuffers.ByteBuffer):InnerStruct {
-  this.bb_pos = i;
-  this.bb = bb;
-  return this;
-}
-
-a():number {
-  return this.bb!.readFloat64(this.bb_pos);
-}
-
-b(index: number):number|null {
-    return this.bb!.readUint8(this.bb_pos + 8 + index);
-}
-
-c():number {
-  return this.bb!.readInt8(this.bb_pos + 21);
-}
-
-dUnderscore():bigint {
-  return this.bb!.readInt64(this.bb_pos + 24);
-}
-
-static getFullyQualifiedName(): "MyGame.Example.InnerStruct" {
-  return 'MyGame.Example.InnerStruct';
-}
-
-static sizeOf():number {
-  return 32;
-}
-
-static createInnerStruct(builder:flatbuffers.Builder, a: number, b: number[], c: number, d_underscore: bigint):flatbuffers.Offset {
-  builder.prep(8, 32);
-  builder.writeInt64(BigInt(d_underscore ?? 0));
-  builder.pad(2);
-  builder.writeInt8(c);
-
-  for (let i = 12; i >= 0; --i) {
-    builder.writeInt8((b?.[i] ?? 0));
-
+export class InnerStruct
+  implements flatbuffers.IUnpackableObject<InnerStructT>
+{
+  bb: flatbuffers.ByteBuffer | null = null;
+  bb_pos = 0;
+  __init(i: number, bb: flatbuffers.ByteBuffer): InnerStruct {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
   }
 
-  builder.writeFloat64(a);
-  return builder.offset();
-}
+  a(): number {
+    return this.bb!.readFloat64(this.bb_pos);
+  }
 
+  b(index: number): number | null {
+    return this.bb!.readUint8(this.bb_pos + 8 + index);
+  }
 
-unpack(): InnerStructT {
-  return new InnerStructT(
-    this.a(),
-    this.bb!.createScalarList<number>(this.b.bind(this), 13),
-    this.c(),
-    this.dUnderscore()
-  );
-}
+  c(): number {
+    return this.bb!.readInt8(this.bb_pos + 21);
+  }
 
+  dUnderscore(): bigint {
+    return this.bb!.readInt64(this.bb_pos + 24);
+  }
 
-unpackTo(_o: InnerStructT): void {
-  _o.a = this.a();
-  _o.b = this.bb!.createScalarList<number>(this.b.bind(this), 13);
-  _o.c = this.c();
-  _o.dUnderscore = this.dUnderscore();
-}
+  static getFullyQualifiedName(): string {
+    return 'MyGame.Example.InnerStruct';
+  }
+
+  static sizeOf(): number {
+    return 32;
+  }
+
+  static createInnerStruct(
+    builder: flatbuffers.Builder,
+    a: number,
+    b: number[] | null,
+    c: number,
+    d_underscore: bigint,
+  ): flatbuffers.Offset {
+    builder.prep(8, 32);
+    builder.writeInt64(BigInt(d_underscore ?? 0));
+    builder.pad(2);
+    builder.writeInt8(c);
+
+    for (let i = 12; i >= 0; --i) {
+      builder.writeInt8(b?.[i] ?? 0);
+    }
+
+    builder.writeFloat64(a);
+    return builder.offset();
+  }
+
+  unpack(): InnerStructT {
+    return new InnerStructT(
+      this.a(),
+      this.bb!.createScalarList<number>(this.b.bind(this), 13),
+      this.c(),
+      this.dUnderscore(),
+    );
+  }
+
+  unpackTo(_o: InnerStructT): void {
+    _o.a = this.a();
+    _o.b = this.bb!.createScalarList<number>(this.b.bind(this), 13);
+    _o.c = this.c();
+    _o.dUnderscore = this.dUnderscore();
+  }
 }
 
 export class InnerStructT implements flatbuffers.IGeneratedObject {
-constructor(
-  public a: number = 0.0,
-  public b: (number)[] = [],
-  public c: number = 0,
-  public dUnderscore: bigint = BigInt('0')
-){}
+  constructor(
+    public a: number = 0.0,
+    public b: number[] = [],
+    public c: number = 0,
+    public dUnderscore: bigint = BigInt('0'),
+  ) {}
 
-
-pack(builder:flatbuffers.Builder): flatbuffers.Offset {
-  return InnerStruct.createInnerStruct(builder,
-    this.a,
-    this.b,
-    this.c,
-    this.dUnderscore
-  );
-}
+  pack(builder: flatbuffers.Builder): flatbuffers.Offset {
+    return InnerStruct.createInnerStruct(
+      builder,
+      this.a,
+      this.b,
+      this.c,
+      this.dUnderscore,
+    );
+  }
 }

tests/ts/arrays_test_complex/my-game/example/nested-struct.d.ts

@@ -1,27 +1,42 @@
 import * as flatbuffers from 'flatbuffers';
-import { OuterStruct, OuterStructT } from './outer-struct.js';
-import { TestEnum } from './test-enum.js';
-export declare class NestedStruct implements flatbuffers.IUnpackableObject<NestedStructT> {
-    bb: flatbuffers.ByteBuffer | null;
-    bb_pos: number;
-    __init(i: number, bb: flatbuffers.ByteBuffer): NestedStruct;
-    a(index: number): number | null;
-    b(): TestEnum;
-    cUnderscore(index: number): TestEnum | null;
-    dOuter(index: number, obj?: OuterStruct): OuterStruct | null;
-    e(index: number): bigint | null;
-    static getFullyQualifiedName(): "MyGame.Example.NestedStruct";
-    static sizeOf(): number;
-    static createNestedStruct(builder: flatbuffers.Builder, a: number[], b: TestEnum, c_underscore: number[], d_outer: (any | OuterStructT)[], e: bigint[]): flatbuffers.Offset;
-    unpack(): NestedStructT;
-    unpackTo(_o: NestedStructT): void;
+import {OuterStruct, OuterStructT} from '../../my-game/example/outer-struct.js';
+import {TestEnum} from '../../my-game/example/test-enum.js';
+export declare class NestedStruct
+  implements flatbuffers.IUnpackableObject<NestedStructT>
+{
+  bb: flatbuffers.ByteBuffer | null;
+  bb_pos: number;
+  __init(i: number, bb: flatbuffers.ByteBuffer): NestedStruct;
+  a(index: number): number | null;
+  b(): TestEnum;
+  cUnderscore(index: number): TestEnum | null;
+  dOuter(index: number, obj?: OuterStruct): OuterStruct | null;
+  e(index: number): bigint | null;
+  static getFullyQualifiedName(): string;
+  static sizeOf(): number;
+  static createNestedStruct(
+    builder: flatbuffers.Builder,
+    a: number[] | null,
+    b: TestEnum,
+    c_underscore: number[] | null,
+    d_outer: (any | OuterStructT)[] | null,
+    e: bigint[] | null,
+  ): flatbuffers.Offset;
+  unpack(): NestedStructT;
+  unpackTo(_o: NestedStructT): void;
 }
 export declare class NestedStructT implements flatbuffers.IGeneratedObject {
-    a: (number)[];
-    b: TestEnum;
-    cUnderscore: (TestEnum)[];
-    dOuter: (OuterStructT)[];
-    e: (bigint)[];
-    constructor(a?: (number)[], b?: TestEnum, cUnderscore?: (TestEnum)[], dOuter?: (OuterStructT)[], e?: (bigint)[]);
-    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+  a: number[];
+  b: TestEnum;
+  cUnderscore: TestEnum[];
+  dOuter: OuterStructT[];
+  e: bigint[];
+  constructor(
+    a?: number[],
+    b?: TestEnum,
+    cUnderscore?: TestEnum[],
+    dOuter?: OuterStructT[],
+    e?: bigint[],
+  );
+  pack(builder: flatbuffers.Builder): flatbuffers.Offset;
 }

tests/ts/arrays_test_complex/my-game/example/nested-struct.js

@@ -1,80 +1,93 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-import { OuterStruct, OuterStructT } from './outer-struct.js';
-import { TestEnum } from './test-enum.js';
+import {OuterStruct, OuterStructT} from '../../my-game/example/outer-struct.js';
+import {TestEnum} from '../../my-game/example/test-enum.js';
 export class NestedStruct {
-    constructor() {
-        this.bb = null;
-        this.bb_pos = 0;
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  a(index) {
+    return this.bb.readInt32(this.bb_pos + 0 + index * 4);
+  }
+  b() {
+    return this.bb.readInt8(this.bb_pos + 8);
+  }
+  cUnderscore(index) {
+    return this.bb.readInt8(this.bb_pos + 9 + index);
+  }
+  dOuter(index, obj) {
+    return (obj || new OuterStruct())
+        .__init(this.bb_pos + 16 + index * 208, this.bb);
+  }
+  e(index) {
+    return this.bb.readInt64(this.bb_pos + 1056 + index * 8);
+  }
+  static getFullyQualifiedName() {
+    return 'MyGame.Example.NestedStruct';
+  }
+  static sizeOf() {
+    return 1072;
+  }
+  static createNestedStruct(builder, a, b, c_underscore, d_outer, e) {
+    builder.prep(8, 1072);
+    for (let i = 1; i >= 0; --i) {
+      builder.writeInt64(BigInt(e?.[i] ?? 0));
     }
-    __init(i, bb) {
-        this.bb_pos = i;
-        this.bb = bb;
-        return this;
+    for (let i = 4; i >= 0; --i) {
+      const item = d_outer?.[i];
+      if (item instanceof OuterStructT) {
+        item.pack(builder);
+        continue;
+      }
+      OuterStruct.createOuterStruct(
+          builder, item?.a, item?.b, (item?.cUnderscore?.a ?? 0),
+          (item?.cUnderscore?.b ?? []), (item?.cUnderscore?.c ?? 0),
+          (item?.cUnderscore?.dUnderscore ?? BigInt(0)), item?.d,
+          (item?.e?.a ?? 0), (item?.e?.b ?? []), (item?.e?.c ?? 0),
+          (item?.e?.dUnderscore ?? BigInt(0)), item?.f);
     }
-    a(index) {
-        return this.bb.readInt32(this.bb_pos + 0 + index * 4);
+    builder.pad(5);
+    for (let i = 1; i >= 0; --i) {
+      builder.writeInt8((c_underscore?.[i] ?? 0));
     }
-    b() {
-        return this.bb.readInt8(this.bb_pos + 8);
-    }
-    cUnderscore(index) {
-        return this.bb.readInt8(this.bb_pos + 9 + index);
-    }
-    dOuter(index, obj) {
-        return (obj || new OuterStruct()).__init(this.bb_pos + 16 + index * 208, this.bb);
-    }
-    e(index) {
-        return this.bb.readInt64(this.bb_pos + 1056 + index * 8);
-    }
-    static getFullyQualifiedName() {
-        return 'MyGame.Example.NestedStruct';
-    }
-    static sizeOf() {
-        return 1072;
-    }
-    static createNestedStruct(builder, a, b, c_underscore, d_outer, e) {
-        builder.prep(8, 1072);
-        for (let i = 1; i >= 0; --i) {
-            builder.writeInt64(BigInt(e?.[i] ?? 0));
-        }
-        for (let i = 4; i >= 0; --i) {
-            const item = d_outer?.[i];
-            if (item instanceof OuterStructT) {
-                item.pack(builder);
-                continue;
-            }
-            OuterStruct.createOuterStruct(builder, item?.a, item?.b, (item?.cUnderscore?.a ?? 0), (item?.cUnderscore?.b ?? []), (item?.cUnderscore?.c ?? 0), (item?.cUnderscore?.dUnderscore ?? BigInt(0)), item?.d, (item?.e?.a ?? 0), (item?.e?.b ?? []), (item?.e?.c ?? 0), (item?.e?.dUnderscore ?? BigInt(0)), item?.f);
-        }
-        builder.pad(5);
-        for (let i = 1; i >= 0; --i) {
-            builder.writeInt8((c_underscore?.[i] ?? 0));
-        }
-        builder.writeInt8(b);
-        for (let i = 1; i >= 0; --i) {
-            builder.writeInt32((a?.[i] ?? 0));
-        }
-        return builder.offset();
-    }
-    unpack() {
-        return new NestedStructT(this.bb.createScalarList(this.a.bind(this), 2), this.b(), this.bb.createScalarList(this.cUnderscore.bind(this), 2), this.bb.createObjList(this.dOuter.bind(this), 5), this.bb.createScalarList(this.e.bind(this), 2));
-    }
-    unpackTo(_o) {
-        _o.a = this.bb.createScalarList(this.a.bind(this), 2);
-        _o.b = this.b();
-        _o.cUnderscore = this.bb.createScalarList(this.cUnderscore.bind(this), 2);
-        _o.dOuter = this.bb.createObjList(this.dOuter.bind(this), 5);
-        _o.e = this.bb.createScalarList(this.e.bind(this), 2);
+    builder.writeInt8(b);
+    for (let i = 1; i >= 0; --i) {
+      builder.writeInt32((a?.[i] ?? 0));
     }
+    return builder.offset();
+  }
+  unpack() {
+    return new NestedStructT(
+        this.bb.createScalarList(this.a.bind(this), 2), this.b(),
+        this.bb.createScalarList(this.cUnderscore.bind(this), 2),
+        this.bb.createObjList(this.dOuter.bind(this), 5),
+        this.bb.createScalarList(this.e.bind(this), 2));
+  }
+  unpackTo(_o) {
+    _o.a = this.bb.createScalarList(this.a.bind(this), 2);
+    _o.b = this.b();
+    _o.cUnderscore = this.bb.createScalarList(this.cUnderscore.bind(this), 2);
+    _o.dOuter = this.bb.createObjList(this.dOuter.bind(this), 5);
+    _o.e = this.bb.createScalarList(this.e.bind(this), 2);
+  }
 }
 export class NestedStructT {
-    constructor(a = [], b = TestEnum.A, cUnderscore = [TestEnum.A, TestEnum.A], dOuter = [], e = []) {
-        this.a = a;
-        this.b = b;
-        this.cUnderscore = cUnderscore;
-        this.dOuter = dOuter;
-        this.e = e;
-    }
-    pack(builder) {
-        return NestedStruct.createNestedStruct(builder, this.a, this.b, this.cUnderscore, this.dOuter, this.e);
-    }
+  constructor(
+      a = [], b = TestEnum.A, cUnderscore = [TestEnum.A, TestEnum.A],
+      dOuter = [], e = []) {
+    this.a = a;
+    this.b = b;
+    this.cUnderscore = cUnderscore;
+    this.dOuter = dOuter;
+    this.e = e;
+  }
+  pack(builder) {
+    return NestedStruct.createNestedStruct(
+        builder, this.a, this.b, this.cUnderscore, this.dOuter, this.e);
+  }
 }

tests/ts/arrays_test_complex/my-game/example/nested-struct.ts

@@ -4,134 +4,150 @@
 
 import * as flatbuffers from 'flatbuffers';
 
-import { OuterStruct, OuterStructT } from './outer-struct.js';
-import { TestEnum } from './test-enum.js';
+import {OuterStruct, OuterStructT} from '../../my-game/example/outer-struct.js';
+import {TestEnum} from '../../my-game/example/test-enum.js';
 
-
-export class NestedStruct implements flatbuffers.IUnpackableObject<NestedStructT> {
-  bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
-  __init(i:number, bb:flatbuffers.ByteBuffer):NestedStruct {
-  this.bb_pos = i;
-  this.bb = bb;
-  return this;
-}
-
-a(index: number):number|null {
-    return this.bb!.readInt32(this.bb_pos + 0 + index * 4);
-}
-
-b():TestEnum {
-  return this.bb!.readInt8(this.bb_pos + 8);
-}
-
-cUnderscore(index: number):TestEnum|null {
-    return this.bb!.readInt8(this.bb_pos + 9 + index);
-}
-
-dOuter(index: number, obj?:OuterStruct):OuterStruct|null {
-    return (obj || new OuterStruct()).__init(this.bb_pos + 16 + index * 208, this.bb!);
-}
-
-e(index: number):bigint|null {
-    return this.bb!.readInt64(this.bb_pos + 1056 + index * 8);
-}
-
-static getFullyQualifiedName(): "MyGame.Example.NestedStruct" {
-  return 'MyGame.Example.NestedStruct';
-}
-
-static sizeOf():number {
-  return 1072;
-}
-
-static createNestedStruct(builder:flatbuffers.Builder, a: number[], b: TestEnum, c_underscore: number[], d_outer: (any|OuterStructT)[], e: bigint[]):flatbuffers.Offset {
-  builder.prep(8, 1072);
-
-  for (let i = 1; i >= 0; --i) {
-    builder.writeInt64(BigInt(e?.[i] ?? 0));
+export class NestedStruct
+  implements flatbuffers.IUnpackableObject<NestedStructT>
+{
+  bb: flatbuffers.ByteBuffer | null = null;
+  bb_pos = 0;
+  __init(i: number, bb: flatbuffers.ByteBuffer): NestedStruct {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
   }
 
+  a(index: number): number | null {
+    return this.bb!.readInt32(this.bb_pos + 0 + index * 4);
+  }
 
-  for (let i = 4; i >= 0; --i) {
-    const item = d_outer?.[i];
+  b(): TestEnum {
+    return this.bb!.readInt8(this.bb_pos + 8);
+  }
 
-    if (item instanceof OuterStructT) {
-      item.pack(builder);
-      continue;
-    }
+  cUnderscore(index: number): TestEnum | null {
+    return this.bb!.readInt8(this.bb_pos + 9 + index);
+  }
 
-    OuterStruct.createOuterStruct(builder,
-    item?.a,
-    item?.b,
-    (item?.cUnderscore?.a ?? 0),
-    (item?.cUnderscore?.b ?? []),
-    (item?.cUnderscore?.c ?? 0),
-    (item?.cUnderscore?.dUnderscore ?? BigInt(0)),
-    item?.d,
-    (item?.e?.a ?? 0),
-    (item?.e?.b ?? []),
-    (item?.e?.c ?? 0),
-    (item?.e?.dUnderscore ?? BigInt(0)),
-    item?.f
+  dOuter(index: number, obj?: OuterStruct): OuterStruct | null {
+    return (obj || new OuterStruct()).__init(
+      this.bb_pos + 16 + index * 208,
+      this.bb!,
     );
   }
 
-  builder.pad(5);
-
-  for (let i = 1; i >= 0; --i) {
-    builder.writeInt8((c_underscore?.[i] ?? 0));
-
+  e(index: number): bigint | null {
+    return this.bb!.readInt64(this.bb_pos + 1056 + index * 8);
   }
 
-  builder.writeInt8(b);
-
-  for (let i = 1; i >= 0; --i) {
-    builder.writeInt32((a?.[i] ?? 0));
-
+  static getFullyQualifiedName(): string {
+    return 'MyGame.Example.NestedStruct';
   }
 
-  return builder.offset();
-}
+  static sizeOf(): number {
+    return 1072;
+  }
 
+  static createNestedStruct(
+    builder: flatbuffers.Builder,
+    a: number[] | null,
+    b: TestEnum,
+    c_underscore: number[] | null,
+    d_outer: (any | OuterStructT)[] | null,
+    e: bigint[] | null,
+  ): flatbuffers.Offset {
+    builder.prep(8, 1072);
 
-unpack(): NestedStructT {
-  return new NestedStructT(
-    this.bb!.createScalarList<number>(this.a.bind(this), 2),
-    this.b(),
-    this.bb!.createScalarList<TestEnum>(this.cUnderscore.bind(this), 2),
-    this.bb!.createObjList<OuterStruct, OuterStructT>(this.dOuter.bind(this), 5),
-    this.bb!.createScalarList<bigint>(this.e.bind(this), 2)
-  );
-}
+    for (let i = 1; i >= 0; --i) {
+      builder.writeInt64(BigInt(e?.[i] ?? 0));
+    }
 
+    for (let i = 4; i >= 0; --i) {
+      const item = d_outer?.[i];
 
-unpackTo(_o: NestedStructT): void {
-  _o.a = this.bb!.createScalarList<number>(this.a.bind(this), 2);
-  _o.b = this.b();
-  _o.cUnderscore = this.bb!.createScalarList<TestEnum>(this.cUnderscore.bind(this), 2);
-  _o.dOuter = this.bb!.createObjList<OuterStruct, OuterStructT>(this.dOuter.bind(this), 5);
-  _o.e = this.bb!.createScalarList<bigint>(this.e.bind(this), 2);
-}
+      if (item instanceof OuterStructT) {
+        item.pack(builder);
+        continue;
+      }
+
+      OuterStruct.createOuterStruct(
+        builder,
+        item?.a,
+        item?.b,
+        item?.cUnderscore?.a ?? 0,
+        item?.cUnderscore?.b ?? [],
+        item?.cUnderscore?.c ?? 0,
+        item?.cUnderscore?.dUnderscore ?? BigInt(0),
+        item?.d,
+        item?.e?.a ?? 0,
+        item?.e?.b ?? [],
+        item?.e?.c ?? 0,
+        item?.e?.dUnderscore ?? BigInt(0),
+        item?.f,
+      );
+    }
+
+    builder.pad(5);
+
+    for (let i = 1; i >= 0; --i) {
+      builder.writeInt8(c_underscore?.[i] ?? 0);
+    }
+
+    builder.writeInt8(b);
+
+    for (let i = 1; i >= 0; --i) {
+      builder.writeInt32(a?.[i] ?? 0);
+    }
+
+    return builder.offset();
+  }
+
+  unpack(): NestedStructT {
+    return new NestedStructT(
+      this.bb!.createScalarList<number>(this.a.bind(this), 2),
+      this.b(),
+      this.bb!.createScalarList<TestEnum>(this.cUnderscore.bind(this), 2),
+      this.bb!.createObjList<OuterStruct, OuterStructT>(
+        this.dOuter.bind(this),
+        5,
+      ),
+      this.bb!.createScalarList<bigint>(this.e.bind(this), 2),
+    );
+  }
+
+  unpackTo(_o: NestedStructT): void {
+    _o.a = this.bb!.createScalarList<number>(this.a.bind(this), 2);
+    _o.b = this.b();
+    _o.cUnderscore = this.bb!.createScalarList<TestEnum>(
+      this.cUnderscore.bind(this),
+      2,
+    );
+    _o.dOuter = this.bb!.createObjList<OuterStruct, OuterStructT>(
+      this.dOuter.bind(this),
+      5,
+    );
+    _o.e = this.bb!.createScalarList<bigint>(this.e.bind(this), 2);
+  }
 }
 
 export class NestedStructT implements flatbuffers.IGeneratedObject {
-constructor(
-  public a: (number)[] = [],
-  public b: TestEnum = TestEnum.A,
-  public cUnderscore: (TestEnum)[] = [TestEnum.A, TestEnum.A],
-  public dOuter: (OuterStructT)[] = [],
-  public e: (bigint)[] = []
-){}
+  constructor(
+    public a: number[] = [],
+    public b: TestEnum = TestEnum.A,
+    public cUnderscore: TestEnum[] = [TestEnum.A, TestEnum.A],
+    public dOuter: OuterStructT[] = [],
+    public e: bigint[] = [],
+  ) {}
 
-
-pack(builder:flatbuffers.Builder): flatbuffers.Offset {
-  return NestedStruct.createNestedStruct(builder,
-    this.a,
-    this.b,
-    this.cUnderscore,
-    this.dOuter,
-    this.e
-  );
-}
+  pack(builder: flatbuffers.Builder): flatbuffers.Offset {
+    return NestedStruct.createNestedStruct(
+      builder,
+      this.a,
+      this.b,
+      this.cUnderscore,
+      this.dOuter,
+      this.e,
+    );
+  }
 }

tests/ts/arrays_test_complex/my-game/example/outer-struct.d.ts

@@ -1,28 +1,51 @@
 import * as flatbuffers from 'flatbuffers';
-import { InnerStruct, InnerStructT } from './inner-struct.js';
-export declare class OuterStruct implements flatbuffers.IUnpackableObject<OuterStructT> {
-    bb: flatbuffers.ByteBuffer | null;
-    bb_pos: number;
-    __init(i: number, bb: flatbuffers.ByteBuffer): OuterStruct;
-    a(): boolean;
-    b(): number;
-    cUnderscore(obj?: InnerStruct): InnerStruct | null;
-    d(index: number, obj?: InnerStruct): InnerStruct | null;
-    e(obj?: InnerStruct): InnerStruct | null;
-    f(index: number): number | null;
-    static getFullyQualifiedName(): "MyGame.Example.OuterStruct";
-    static sizeOf(): number;
-    static createOuterStruct(builder: flatbuffers.Builder, a: boolean, b: number, c_underscore_a: number, c_underscore_b: number[], c_underscore_c: number, c_underscore_d_underscore: bigint, d: (any | InnerStructT)[], e_a: number, e_b: number[], e_c: number, e_d_underscore: bigint, f: number[]): flatbuffers.Offset;
-    unpack(): OuterStructT;
-    unpackTo(_o: OuterStructT): void;
+import {InnerStruct, InnerStructT} from '../../my-game/example/inner-struct.js';
+export declare class OuterStruct
+  implements flatbuffers.IUnpackableObject<OuterStructT>
+{
+  bb: flatbuffers.ByteBuffer | null;
+  bb_pos: number;
+  __init(i: number, bb: flatbuffers.ByteBuffer): OuterStruct;
+  a(): boolean;
+  b(): number;
+  cUnderscore(obj?: InnerStruct): InnerStruct | null;
+  d(index: number, obj?: InnerStruct): InnerStruct | null;
+  e(obj?: InnerStruct): InnerStruct | null;
+  f(index: number): number | null;
+  static getFullyQualifiedName(): string;
+  static sizeOf(): number;
+  static createOuterStruct(
+    builder: flatbuffers.Builder,
+    a: boolean,
+    b: number,
+    c_underscore_a: number,
+    c_underscore_b: number[] | null,
+    c_underscore_c: number,
+    c_underscore_d_underscore: bigint,
+    d: (any | InnerStructT)[] | null,
+    e_a: number,
+    e_b: number[] | null,
+    e_c: number,
+    e_d_underscore: bigint,
+    f: number[] | null,
+  ): flatbuffers.Offset;
+  unpack(): OuterStructT;
+  unpackTo(_o: OuterStructT): void;
 }
 export declare class OuterStructT implements flatbuffers.IGeneratedObject {
-    a: boolean;
-    b: number;
-    cUnderscore: InnerStructT | null;
-    d: (InnerStructT)[];
-    e: InnerStructT | null;
-    f: (number)[];
-    constructor(a?: boolean, b?: number, cUnderscore?: InnerStructT | null, d?: (InnerStructT)[], e?: InnerStructT | null, f?: (number)[]);
-    pack(builder: flatbuffers.Builder): flatbuffers.Offset;
+  a: boolean;
+  b: number;
+  cUnderscore: InnerStructT | null;
+  d: InnerStructT[];
+  e: InnerStructT | null;
+  f: number[];
+  constructor(
+    a?: boolean,
+    b?: number,
+    cUnderscore?: InnerStructT | null,
+    d?: InnerStructT[],
+    e?: InnerStructT | null,
+    f?: number[],
+  );
+  pack(builder: flatbuffers.Builder): flatbuffers.Offset;
 }

tests/ts/arrays_test_complex/my-game/example/outer-struct.js

@@ -1,95 +1,111 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-import { InnerStruct, InnerStructT } from './inner-struct.js';
+import {InnerStruct, InnerStructT} from '../../my-game/example/inner-struct.js';
 export class OuterStruct {
-    constructor() {
-        this.bb = null;
-        this.bb_pos = 0;
+  constructor() {
+    this.bb = null;
+    this.bb_pos = 0;
+  }
+  __init(i, bb) {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
+  a() {
+    return !!this.bb.readInt8(this.bb_pos);
+  }
+  b() {
+    return this.bb.readFloat64(this.bb_pos + 8);
+  }
+  cUnderscore(obj) {
+    return (obj || new InnerStruct()).__init(this.bb_pos + 16, this.bb);
+  }
+  d(index, obj) {
+    return (obj || new InnerStruct())
+        .__init(this.bb_pos + 48 + index * 32, this.bb);
+  }
+  e(obj) {
+    return (obj || new InnerStruct()).__init(this.bb_pos + 144, this.bb);
+  }
+  f(index) {
+    return this.bb.readFloat64(this.bb_pos + 176 + index * 8);
+  }
+  static getFullyQualifiedName() {
+    return 'MyGame.Example.OuterStruct';
+  }
+  static sizeOf() {
+    return 208;
+  }
+  static createOuterStruct(
+      builder, a, b, c_underscore_a, c_underscore_b, c_underscore_c,
+      c_underscore_d_underscore, d, e_a, e_b, e_c, e_d_underscore, f) {
+    builder.prep(8, 208);
+    for (let i = 3; i >= 0; --i) {
+      builder.writeFloat64((f?.[i] ?? 0));
     }
-    __init(i, bb) {
-        this.bb_pos = i;
-        this.bb = bb;
-        return this;
+    builder.prep(8, 32);
+    builder.writeInt64(BigInt(e_d_underscore ?? 0));
+    builder.pad(2);
+    builder.writeInt8(e_c);
+    for (let i = 12; i >= 0; --i) {
+      builder.writeInt8((e_b?.[i] ?? 0));
     }
-    a() {
-        return !!this.bb.readInt8(this.bb_pos);
+    builder.writeFloat64(e_a);
+    for (let i = 2; i >= 0; --i) {
+      const item = d?.[i];
+      if (item instanceof InnerStructT) {
+        item.pack(builder);
+        continue;
+      }
+      InnerStruct.createInnerStruct(
+          builder, item?.a, item?.b, item?.c, item?.dUnderscore);
     }
-    b() {
-        return this.bb.readFloat64(this.bb_pos + 8);
-    }
-    cUnderscore(obj) {
-        return (obj || new InnerStruct()).__init(this.bb_pos + 16, this.bb);
-    }
-    d(index, obj) {
-        return (obj || new InnerStruct()).__init(this.bb_pos + 48 + index * 32, this.bb);
-    }
-    e(obj) {
-        return (obj || new InnerStruct()).__init(this.bb_pos + 144, this.bb);
-    }
-    f(index) {
-        return this.bb.readFloat64(this.bb_pos + 176 + index * 8);
-    }
-    static getFullyQualifiedName() {
-        return 'MyGame.Example.OuterStruct';
-    }
-    static sizeOf() {
-        return 208;
-    }
-    static createOuterStruct(builder, a, b, c_underscore_a, c_underscore_b, c_underscore_c, c_underscore_d_underscore, d, e_a, e_b, e_c, e_d_underscore, f) {
-        builder.prep(8, 208);
-        for (let i = 3; i >= 0; --i) {
-            builder.writeFloat64((f?.[i] ?? 0));
-        }
-        builder.prep(8, 32);
-        builder.writeInt64(BigInt(e_d_underscore ?? 0));
-        builder.pad(2);
-        builder.writeInt8(e_c);
-        for (let i = 12; i >= 0; --i) {
-            builder.writeInt8((e_b?.[i] ?? 0));
-        }
-        builder.writeFloat64(e_a);
-        for (let i = 2; i >= 0; --i) {
-            const item = d?.[i];
-            if (item instanceof InnerStructT) {
-                item.pack(builder);
-                continue;
-            }
-            InnerStruct.createInnerStruct(builder, item?.a, item?.b, item?.c, item?.dUnderscore);
-        }
-        builder.prep(8, 32);
-        builder.writeInt64(BigInt(c_underscore_d_underscore ?? 0));
-        builder.pad(2);
-        builder.writeInt8(c_underscore_c);
-        for (let i = 12; i >= 0; --i) {
-            builder.writeInt8((c_underscore_b?.[i] ?? 0));
-        }
-        builder.writeFloat64(c_underscore_a);
-        builder.writeFloat64(b);
-        builder.pad(7);
-        builder.writeInt8(Number(Boolean(a)));
-        return builder.offset();
-    }
-    unpack() {
-        return new OuterStructT(this.a(), this.b(), (this.cUnderscore() !== null ? this.cUnderscore().unpack() : null), this.bb.createObjList(this.d.bind(this), 3), (this.e() !== null ? this.e().unpack() : null), this.bb.createScalarList(this.f.bind(this), 4));
-    }
-    unpackTo(_o) {
-        _o.a = this.a();
-        _o.b = this.b();
-        _o.cUnderscore = (this.cUnderscore() !== null ? this.cUnderscore().unpack() : null);
-        _o.d = this.bb.createObjList(this.d.bind(this), 3);
-        _o.e = (this.e() !== null ? this.e().unpack() : null);
-        _o.f = this.bb.createScalarList(this.f.bind(this), 4);
+    builder.prep(8, 32);
+    builder.writeInt64(BigInt(c_underscore_d_underscore ?? 0));
+    builder.pad(2);
+    builder.writeInt8(c_underscore_c);
+    for (let i = 12; i >= 0; --i) {
+      builder.writeInt8((c_underscore_b?.[i] ?? 0));
     }
+    builder.writeFloat64(c_underscore_a);
+    builder.writeFloat64(b);
+    builder.pad(7);
+    builder.writeInt8(Number(Boolean(a)));
+    return builder.offset();
+  }
+  unpack() {
+    return new OuterStructT(
+        this.a(), this.b(),
+        (this.cUnderscore() !== null ? this.cUnderscore().unpack() : null),
+        this.bb.createObjList(this.d.bind(this), 3),
+        (this.e() !== null ? this.e().unpack() : null),
+        this.bb.createScalarList(this.f.bind(this), 4));
+  }
+  unpackTo(_o) {
+    _o.a = this.a();
+    _o.b = this.b();
+    _o.cUnderscore =
+        (this.cUnderscore() !== null ? this.cUnderscore().unpack() : null);
+    _o.d = this.bb.createObjList(this.d.bind(this), 3);
+    _o.e = (this.e() !== null ? this.e().unpack() : null);
+    _o.f = this.bb.createScalarList(this.f.bind(this), 4);
+  }
 }
 export class OuterStructT {
-    constructor(a = false, b = 0.0, cUnderscore = null, d = [], e = null, f = []) {
-        this.a = a;
-        this.b = b;
-        this.cUnderscore = cUnderscore;
-        this.d = d;
-        this.e = e;
-        this.f = f;
-    }
-    pack(builder) {
-        return OuterStruct.createOuterStruct(builder, this.a, this.b, (this.cUnderscore?.a ?? 0), (this.cUnderscore?.b ?? []), (this.cUnderscore?.c ?? 0), (this.cUnderscore?.dUnderscore ?? BigInt(0)), this.d, (this.e?.a ?? 0), (this.e?.b ?? []), (this.e?.c ?? 0), (this.e?.dUnderscore ?? BigInt(0)), this.f);
-    }
+  constructor(
+      a = false, b = 0.0, cUnderscore = null, d = [], e = null, f = []) {
+    this.a = a;
+    this.b = b;
+    this.cUnderscore = cUnderscore;
+    this.d = d;
+    this.e = e;
+    this.f = f;
+  }
+  pack(builder) {
+    return OuterStruct.createOuterStruct(
+        builder, this.a, this.b, (this.cUnderscore?.a ?? 0),
+        (this.cUnderscore?.b ?? []), (this.cUnderscore?.c ?? 0),
+        (this.cUnderscore?.dUnderscore ?? BigInt(0)), this.d, (this.e?.a ?? 0),
+        (this.e?.b ?? []), (this.e?.c ?? 0), (this.e?.dUnderscore ?? BigInt(0)),
+        this.f);
+  }
 }

tests/ts/arrays_test_complex/my-game/example/outer-struct.ts

@@ -4,151 +4,169 @@
 
 import * as flatbuffers from 'flatbuffers';
 
-import { InnerStruct, InnerStructT } from './inner-struct.js';
-
-
-export class OuterStruct implements flatbuffers.IUnpackableObject<OuterStructT> {
-  bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
-  __init(i:number, bb:flatbuffers.ByteBuffer):OuterStruct {
-  this.bb_pos = i;
-  this.bb = bb;
-  return this;
-}
-
-a():boolean {
-  return !!this.bb!.readInt8(this.bb_pos);
-}
-
-b():number {
-  return this.bb!.readFloat64(this.bb_pos + 8);
-}
-
-cUnderscore(obj?:InnerStruct):InnerStruct|null {
-  return (obj || new InnerStruct()).__init(this.bb_pos + 16, this.bb!);
-}
-
-d(index: number, obj?:InnerStruct):InnerStruct|null {
-    return (obj || new InnerStruct()).__init(this.bb_pos + 48 + index * 32, this.bb!);
-}
-
-e(obj?:InnerStruct):InnerStruct|null {
-  return (obj || new InnerStruct()).__init(this.bb_pos + 144, this.bb!);
-}
-
-f(index: number):number|null {
-    return this.bb!.readFloat64(this.bb_pos + 176 + index * 8);
-}
-
-static getFullyQualifiedName(): "MyGame.Example.OuterStruct" {
-  return 'MyGame.Example.OuterStruct';
-}
-
-static sizeOf():number {
-  return 208;
-}
-
-static createOuterStruct(builder:flatbuffers.Builder, a: boolean, b: number, c_underscore_a: number, c_underscore_b: number[], c_underscore_c: number, c_underscore_d_underscore: bigint, d: (any|InnerStructT)[], e_a: number, e_b: number[], e_c: number, e_d_underscore: bigint, f: number[]):flatbuffers.Offset {
-  builder.prep(8, 208);
-
-  for (let i = 3; i >= 0; --i) {
-    builder.writeFloat64((f?.[i] ?? 0));
+import {InnerStruct, InnerStructT} from '../../my-game/example/inner-struct.js';
 
+export class OuterStruct
+  implements flatbuffers.IUnpackableObject<OuterStructT>
+{
+  bb: flatbuffers.ByteBuffer | null = null;
+  bb_pos = 0;
+  __init(i: number, bb: flatbuffers.ByteBuffer): OuterStruct {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
   }
 
-  builder.prep(8, 32);
-  builder.writeInt64(BigInt(e_d_underscore ?? 0));
-  builder.pad(2);
-  builder.writeInt8(e_c);
-
-  for (let i = 12; i >= 0; --i) {
-    builder.writeInt8((e_b?.[i] ?? 0));
-
+  a(): boolean {
+    return !!this.bb!.readInt8(this.bb_pos);
   }
 
-  builder.writeFloat64(e_a);
+  b(): number {
+    return this.bb!.readFloat64(this.bb_pos + 8);
+  }
 
-  for (let i = 2; i >= 0; --i) {
-    const item = d?.[i];
+  cUnderscore(obj?: InnerStruct): InnerStruct | null {
+    return (obj || new InnerStruct()).__init(this.bb_pos + 16, this.bb!);
+  }
 
-    if (item instanceof InnerStructT) {
-      item.pack(builder);
-      continue;
-    }
-
-    InnerStruct.createInnerStruct(builder,
-    item?.a,
-    item?.b,
-    item?.c,
-    item?.dUnderscore
+  d(index: number, obj?: InnerStruct): InnerStruct | null {
+    return (obj || new InnerStruct()).__init(
+      this.bb_pos + 48 + index * 32,
+      this.bb!,
     );
   }
 
-  builder.prep(8, 32);
-  builder.writeInt64(BigInt(c_underscore_d_underscore ?? 0));
-  builder.pad(2);
-  builder.writeInt8(c_underscore_c);
-
-  for (let i = 12; i >= 0; --i) {
-    builder.writeInt8((c_underscore_b?.[i] ?? 0));
-
+  e(obj?: InnerStruct): InnerStruct | null {
+    return (obj || new InnerStruct()).__init(this.bb_pos + 144, this.bb!);
   }
 
-  builder.writeFloat64(c_underscore_a);
-  builder.writeFloat64(b);
-  builder.pad(7);
-  builder.writeInt8(Number(Boolean(a)));
-  return builder.offset();
-}
+  f(index: number): number | null {
+    return this.bb!.readFloat64(this.bb_pos + 176 + index * 8);
+  }
 
+  static getFullyQualifiedName(): string {
+    return 'MyGame.Example.OuterStruct';
+  }
 
-unpack(): OuterStructT {
-  return new OuterStructT(
-    this.a(),
-    this.b(),
-    (this.cUnderscore() !== null ? this.cUnderscore()!.unpack() : null),
-    this.bb!.createObjList<InnerStruct, InnerStructT>(this.d.bind(this), 3),
-    (this.e() !== null ? this.e()!.unpack() : null),
-    this.bb!.createScalarList<number>(this.f.bind(this), 4)
-  );
-}
+  static sizeOf(): number {
+    return 208;
+  }
 
+  static createOuterStruct(
+    builder: flatbuffers.Builder,
+    a: boolean,
+    b: number,
+    c_underscore_a: number,
+    c_underscore_b: number[] | null,
+    c_underscore_c: number,
+    c_underscore_d_underscore: bigint,
+    d: (any | InnerStructT)[] | null,
+    e_a: number,
+    e_b: number[] | null,
+    e_c: number,
+    e_d_underscore: bigint,
+    f: number[] | null,
+  ): flatbuffers.Offset {
+    builder.prep(8, 208);
 
-unpackTo(_o: OuterStructT): void {
-  _o.a = this.a();
-  _o.b = this.b();
-  _o.cUnderscore = (this.cUnderscore() !== null ? this.cUnderscore()!.unpack() : null);
-  _o.d = this.bb!.createObjList<InnerStruct, InnerStructT>(this.d.bind(this), 3);
-  _o.e = (this.e() !== null ? this.e()!.unpack() : null);
-  _o.f = this.bb!.createScalarList<number>(this.f.bind(this), 4);
-}
+    for (let i = 3; i >= 0; --i) {
+      builder.writeFloat64(f?.[i] ?? 0);
+    }
+
+    builder.prep(8, 32);
+    builder.writeInt64(BigInt(e_d_underscore ?? 0));
+    builder.pad(2);
+    builder.writeInt8(e_c);
+
+    for (let i = 12; i >= 0; --i) {
+      builder.writeInt8(e_b?.[i] ?? 0);
+    }
+
+    builder.writeFloat64(e_a);
+
+    for (let i = 2; i >= 0; --i) {
+      const item = d?.[i];
+
+      if (item instanceof InnerStructT) {
+        item.pack(builder);
+        continue;
+      }
+
+      InnerStruct.createInnerStruct(
+        builder,
+        item?.a,
+        item?.b,
+        item?.c,
+        item?.dUnderscore,
+      );
+    }
+
+    builder.prep(8, 32);
+    builder.writeInt64(BigInt(c_underscore_d_underscore ?? 0));
+    builder.pad(2);
+    builder.writeInt8(c_underscore_c);
+
+    for (let i = 12; i >= 0; --i) {
+      builder.writeInt8(c_underscore_b?.[i] ?? 0);
+    }
+
+    builder.writeFloat64(c_underscore_a);
+    builder.writeFloat64(b);
+    builder.pad(7);
+    builder.writeInt8(Number(Boolean(a)));
+    return builder.offset();
+  }
+
+  unpack(): OuterStructT {
+    return new OuterStructT(
+      this.a(),
+      this.b(),
+      this.cUnderscore() !== null ? this.cUnderscore()!.unpack() : null,
+      this.bb!.createObjList<InnerStruct, InnerStructT>(this.d.bind(this), 3),
+      this.e() !== null ? this.e()!.unpack() : null,
+      this.bb!.createScalarList<number>(this.f.bind(this), 4),
+    );
+  }
+
+  unpackTo(_o: OuterStructT): void {
+    _o.a = this.a();
+    _o.b = this.b();
+    _o.cUnderscore =
+      this.cUnderscore() !== null ? this.cUnderscore()!.unpack() : null;
+    _o.d = this.bb!.createObjList<InnerStruct, InnerStructT>(
+      this.d.bind(this),
+      3,
+    );
+    _o.e = this.e() !== null ? this.e()!.unpack() : null;
+    _o.f = this.bb!.createScalarList<number>(this.f.bind(this), 4);
+  }
 }
 
 export class OuterStructT implements flatbuffers.IGeneratedObject {
-constructor(
-  public a: boolean = false,
-  public b: number = 0.0,
-  public cUnderscore: InnerStructT|null = null,
-  public d: (InnerStructT)[] = [],
-  public e: InnerStructT|null = null,
-  public f: (number)[] = []
-){}
+  constructor(
+    public a: boolean = false,
+    public b: number = 0.0,
+    public cUnderscore: InnerStructT | null = null,
+    public d: InnerStructT[] = [],
+    public e: InnerStructT | null = null,
+    public f: number[] = [],
+  ) {}
 
-
-pack(builder:flatbuffers.Builder): flatbuffers.Offset {
-  return OuterStruct.createOuterStruct(builder,
-    this.a,
-    this.b,
-    (this.cUnderscore?.a ?? 0),
-    (this.cUnderscore?.b ?? []),
-    (this.cUnderscore?.c ?? 0),
-    (this.cUnderscore?.dUnderscore ?? BigInt(0)),
-    this.d,
-    (this.e?.a ?? 0),
-    (this.e?.b ?? []),
-    (this.e?.c ?? 0),
-    (this.e?.dUnderscore ?? BigInt(0)),
-    this.f
-  );
-}
+  pack(builder: flatbuffers.Builder): flatbuffers.Offset {
+    return OuterStruct.createOuterStruct(
+      builder,
+      this.a,
+      this.b,
+      this.cUnderscore?.a ?? 0,
+      this.cUnderscore?.b ?? [],
+      this.cUnderscore?.c ?? 0,
+      this.cUnderscore?.dUnderscore ?? BigInt(0),
+      this.d,
+      this.e?.a ?? 0,
+      this.e?.b ?? [],
+      this.e?.c ?? 0,
+      this.e?.dUnderscore ?? BigInt(0),
+      this.f,
+    );
+  }
 }

tests/ts/arrays_test_complex/my-game/example/test-enum.d.ts

@@ -1,5 +1,5 @@
 export declare enum TestEnum {
-    A = 0,
-    B = 1,
-    C = 2
+  A = 0,
+  B = 1,
+  C = 2,
 }

tests/ts/arrays_test_complex/my-game/example/test-enum.js

@@ -1,8 +1,9 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any,
+ * @typescript-eslint/no-non-null-assertion */
 export var TestEnum;
-(function (TestEnum) {
-    TestEnum[TestEnum["A"] = 0] = "A";
-    TestEnum[TestEnum["B"] = 1] = "B";
-    TestEnum[TestEnum["C"] = 2] = "C";
+(function(TestEnum) {
+TestEnum[TestEnum['A'] = 0] = 'A';
+TestEnum[TestEnum['B'] = 1] = 'B';
+TestEnum[TestEnum['C'] = 2] = 'C';
 })(TestEnum || (TestEnum = {}));

tests/ts/arrays_test_complex/my-game/example/test-enum.ts

@@ -5,5 +5,5 @@
 export enum TestEnum {
   A = 0,
   B = 1,
-  C = 2
+  C = 2,
 }

tests/ts/com/company/test/person.ts

@@ -4,67 +4,86 @@
 
 import * as flatbuffers from 'flatbuffers';
 
-
-
 export class Person {
-  bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
-  __init(i:number, bb:flatbuffers.ByteBuffer):Person {
-  this.bb_pos = i;
-  this.bb = bb;
-  return this;
-}
+  bb: flatbuffers.ByteBuffer | null = null;
+  bb_pos = 0;
+  __init(i: number, bb: flatbuffers.ByteBuffer): Person {
+    this.bb_pos = i;
+    this.bb = bb;
+    return this;
+  }
 
-static getRootAsPerson(bb:flatbuffers.ByteBuffer, obj?:Person):Person {
-  return (obj || new Person()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
-}
+  static getRootAsPerson(bb: flatbuffers.ByteBuffer, obj?: Person): Person {
+    return (obj || new Person()).__init(
+      bb.readInt32(bb.position()) + bb.position(),
+      bb,
+    );
+  }
 
-static getSizePrefixedRootAsPerson(bb:flatbuffers.ByteBuffer, obj?:Person):Person {
-  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
-  return (obj || new Person()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
-}
+  static getSizePrefixedRootAsPerson(
+    bb: flatbuffers.ByteBuffer,
+    obj?: Person,
+  ): Person {
+    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+    return (obj || new Person()).__init(
+      bb.readInt32(bb.position()) + bb.position(),
+      bb,
+    );
+  }
 
-name():string|null
-name(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
-name(optionalEncoding?:any):string|Uint8Array|null {
-  const offset = this.bb!.__offset(this.bb_pos, 4);
-  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
-}
+  name(): string | null;
+  name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+  name(optionalEncoding?: any): string | Uint8Array | null {
+    const offset = this.bb!.__offset(this.bb_pos, 4);
+    return offset
+      ? this.bb!.__string(this.bb_pos + offset, optionalEncoding)
+      : null;
+  }
 
-age():number {
-  const offset = this.bb!.__offset(this.bb_pos, 6);
-  return offset ? this.bb!.readInt16(this.bb_pos + offset) : 0;
-}
+  age(): number {
+    const offset = this.bb!.__offset(this.bb_pos, 6);
+    return offset ? this.bb!.readInt16(this.bb_pos + offset) : 0;
+  }
 
-static startPerson(builder:flatbuffers.Builder):void {
-  builder.startObject(2);
-}
+  static startPerson(builder: flatbuffers.Builder) {
+    builder.startObject(2);
+  }
 
-static addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(0, nameOffset, 0);
-}
+  static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset) {
+    builder.addFieldOffset(0, nameOffset, 0);
+  }
 
-static addAge(builder:flatbuffers.Builder, age:number):void {
-  builder.addFieldInt16(1, age, 0);
-}
+  static addAge(builder: flatbuffers.Builder, age: number) {
+    builder.addFieldInt16(1, age, 0);
+  }
 
-static endPerson(builder:flatbuffers.Builder):flatbuffers.Offset {
-  const offset = builder.endObject();
-  return offset;
-}
+  static endPerson(builder: flatbuffers.Builder): flatbuffers.Offset {
+    const offset = builder.endObject();
+    return offset;
+  }
 
-static finishPersonBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset):void {
-  builder.finish(offset);
-}
+  static finishPersonBuffer(
+    builder: flatbuffers.Builder,
+    offset: flatbuffers.Offset,
+  ) {
+    builder.finish(offset);
+  }
 
-static finishSizePrefixedPersonBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset):void {
-  builder.finish(offset, undefined, true);
-}
+  static finishSizePrefixedPersonBuffer(
+    builder: flatbuffers.Builder,
+    offset: flatbuffers.Offset,
+  ) {
+    builder.finish(offset, undefined, true);
+  }
 
-static createPerson(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset, age:number):flatbuffers.Offset {
-  Person.startPerson(builder);
-  Person.addName(builder, nameOffset);
-  Person.addAge(builder, age);
-  return Person.endPerson(builder);
-}
+  static createPerson(
+    builder: flatbuffers.Builder,
+    nameOffset: flatbuffers.Offset,
+    age: number,
+  ): flatbuffers.Offset {
+    Person.startPerson(builder);
+    Person.addName(builder, nameOffset);
+    Person.addAge(builder, age);
+    return Person.endPerson(builder);
+  }
 }

tests/ts/even-more-defaults.ts

@@ -1,473 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-
-import * as flatbuffers from 'flatbuffers';
-
-import { ABC } from './abc.js';
-import { EvenMoreStruct, EvenMoreStructT } from './even-more-struct.js';
-
-
-export class EvenMoreDefaults implements flatbuffers.IUnpackableObject<EvenMoreDefaultsT> {
-  bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
-  __init(i:number, bb:flatbuffers.ByteBuffer):EvenMoreDefaults {
-  this.bb_pos = i;
-  this.bb = bb;
-  return this;
-}
-
-static getRootAsEvenMoreDefaults(bb:flatbuffers.ByteBuffer, obj?:EvenMoreDefaults):EvenMoreDefaults {
-  return (obj || new EvenMoreDefaults()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
-}
-
-static getSizePrefixedRootAsEvenMoreDefaults(bb:flatbuffers.ByteBuffer, obj?:EvenMoreDefaults):EvenMoreDefaults {
-  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
-  return (obj || new EvenMoreDefaults()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
-}
-
-str(obj?:EvenMoreStruct):EvenMoreStruct|null {
-  const offset = this.bb!.__offset(this.bb_pos, 4);
-  return offset ? (obj || new EvenMoreStruct()).__init(this.bb_pos + offset, this.bb!) : null;
-}
-
-ints(index: number):number|null {
-  const offset = this.bb!.__offset(this.bb_pos, 6);
-  return offset ? this.bb!.readInt32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : 0;
-}
-
-intsLength():number {
-  const offset = this.bb!.__offset(this.bb_pos, 6);
-  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
-}
-
-intsArray():Int32Array {
-  const offset = this.bb!.__offset(this.bb_pos, 6);
-  return offset ? new Int32Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : new Int32Array();
-}
-
-floats(index: number):number|null {
-  const offset = this.bb!.__offset(this.bb_pos, 8);
-  return offset ? this.bb!.readFloat32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : 0;
-}
-
-floatsLength():number {
-  const offset = this.bb!.__offset(this.bb_pos, 8);
-  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
-}
-
-floatsArray():Float32Array {
-  const offset = this.bb!.__offset(this.bb_pos, 8);
-  return offset ? new Float32Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : new Float32Array();
-}
-
-floatOptional(index: number):number|null {
-  const offset = this.bb!.__offset(this.bb_pos, 10);
-  return offset ? this.bb!.readFloat32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : 0;
-}
-
-floatOptionalLength():number {
-  const offset = this.bb!.__offset(this.bb_pos, 10);
-  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
-}
-
-floatOptionalArray():Float32Array|null {
-  const offset = this.bb!.__offset(this.bb_pos, 10);
-  return offset ? new Float32Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
-}
-
-bytesOptional(index: number):number|null {
-  const offset = this.bb!.__offset(this.bb_pos, 12);
-  return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0;
-}
-
-bytesOptionalLength():number {
-  const offset = this.bb!.__offset(this.bb_pos, 12);
-  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
-}
-
-bytesOptionalArray():Uint8Array|null {
-  const offset = this.bb!.__offset(this.bb_pos, 12);
-  return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
-}
-
-floatsRequired(index: number):number|null {
-  const offset = this.bb!.__offset(this.bb_pos, 14);
-  return offset ? this.bb!.readFloat32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : 0;
-}
-
-floatsRequiredLength():number {
-  const offset = this.bb!.__offset(this.bb_pos, 14);
-  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
-}
-
-floatsRequiredArray():Float32Array {
-  const offset = this.bb!.__offset(this.bb_pos, 14);
-  return new Float32Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset));
-}
-
-emptyString():string
-emptyString(optionalEncoding:flatbuffers.Encoding):string|Uint8Array
-emptyString(optionalEncoding?:any):string|Uint8Array {
-  const offset = this.bb!.__offset(this.bb_pos, 16);
-  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : "";
-}
-
-someString():string
-someString(optionalEncoding:flatbuffers.Encoding):string|Uint8Array
-someString(optionalEncoding?:any):string|Uint8Array {
-  const offset = this.bb!.__offset(this.bb_pos, 18);
-  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : "some";
-}
-
-zeroString():string|null
-zeroString(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
-zeroString(optionalEncoding?:any):string|Uint8Array|null {
-  const offset = this.bb!.__offset(this.bb_pos, 20);
-  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
-}
-
-aString():string
-aString(optionalEncoding:flatbuffers.Encoding):string|Uint8Array
-aString(optionalEncoding?:any):string|Uint8Array {
-  const offset = this.bb!.__offset(this.bb_pos, 22);
-  return this.bb!.__string(this.bb_pos + offset, optionalEncoding);
-}
-
-requiredString():string
-requiredString(optionalEncoding:flatbuffers.Encoding):string|Uint8Array
-requiredString(optionalEncoding?:any):string|Uint8Array {
-  const offset = this.bb!.__offset(this.bb_pos, 24);
-  return this.bb!.__string(this.bb_pos + offset, optionalEncoding);
-}
-
-abcs(index: number):ABC|null {
-  const offset = this.bb!.__offset(this.bb_pos, 26);
-  return offset ? this.bb!.readInt32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : null;
-}
-
-abcsLength():number {
-  const offset = this.bb!.__offset(this.bb_pos, 26);
-  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
-}
-
-abcsArray():Int32Array {
-  const offset = this.bb!.__offset(this.bb_pos, 26);
-  return offset ? new Int32Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : new Int32Array();
-}
-
-bools(index: number):boolean|null {
-  const offset = this.bb!.__offset(this.bb_pos, 28);
-  return offset ? !!this.bb!.readInt8(this.bb!.__vector(this.bb_pos + offset) + index) : false;
-}
-
-boolsLength():number {
-  const offset = this.bb!.__offset(this.bb_pos, 28);
-  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
-}
-
-boolsArray():Int8Array {
-  const offset = this.bb!.__offset(this.bb_pos, 28);
-  return offset ? new Int8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : new Int8Array();
-}
-
-oneBool():boolean {
-  const offset = this.bb!.__offset(this.bb_pos, 30);
-  return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : true;
-}
-
-mutate_one_bool(value:boolean):boolean {
-  const offset = this.bb!.__offset(this.bb_pos, 30);
-
-  if (offset === 0) {
-    return false;
-  }
-
-  this.bb!.writeInt8(this.bb_pos + offset, +value);
-  return true;
-}
-
-static getFullyQualifiedName(): "EvenMoreDefaults" {
-  return 'EvenMoreDefaults';
-}
-
-static startEvenMoreDefaults(builder:flatbuffers.Builder):void {
-  builder.startObject(14);
-}
-
-static addStr(builder:flatbuffers.Builder, strOffset:flatbuffers.Offset):void {
-  builder.addFieldStruct(0, strOffset, 0);
-}
-
-static addInts(builder:flatbuffers.Builder, intsOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(1, intsOffset, 0);
-}
-
-static createIntsVector(builder:flatbuffers.Builder, data:number[]|Int32Array):flatbuffers.Offset;
-/**
- * @deprecated This Uint8Array overload will be removed in the future.
- */
-static createIntsVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset;
-static createIntsVector(builder:flatbuffers.Builder, data:number[]|Int32Array|Uint8Array):flatbuffers.Offset {
-  builder.startVector(4, data.length, 4);
-  for (let i = data.length - 1; i >= 0; i--) {
-    builder.addInt32(data[i]!);
-  }
-  return builder.endVector();
-}
-
-static startIntsVector(builder:flatbuffers.Builder, numElems:number):void {
-  builder.startVector(4, numElems, 4);
-}
-
-static addFloats(builder:flatbuffers.Builder, floatsOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(2, floatsOffset, 0);
-}
-
-static createFloatsVector(builder:flatbuffers.Builder, data:number[]|Float32Array):flatbuffers.Offset;
-/**
- * @deprecated This Uint8Array overload will be removed in the future.
- */
-static createFloatsVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset;
-static createFloatsVector(builder:flatbuffers.Builder, data:number[]|Float32Array|Uint8Array):flatbuffers.Offset {
-  builder.startVector(4, data.length, 4);
-  for (let i = data.length - 1; i >= 0; i--) {
-    builder.addFloat32(data[i]!);
-  }
-  return builder.endVector();
-}
-
-static startFloatsVector(builder:flatbuffers.Builder, numElems:number):void {
-  builder.startVector(4, numElems, 4);
-}
-
-static addFloatOptional(builder:flatbuffers.Builder, floatOptionalOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(3, floatOptionalOffset, 0);
-}
-
-static createFloatOptionalVector(builder:flatbuffers.Builder, data:number[]|Float32Array):flatbuffers.Offset;
-/**
- * @deprecated This Uint8Array overload will be removed in the future.
- */
-static createFloatOptionalVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset;
-static createFloatOptionalVector(builder:flatbuffers.Builder, data:number[]|Float32Array|Uint8Array):flatbuffers.Offset {
-  builder.startVector(4, data.length, 4);
-  for (let i = data.length - 1; i >= 0; i--) {
-    builder.addFloat32(data[i]!);
-  }
-  return builder.endVector();
-}
-
-static startFloatOptionalVector(builder:flatbuffers.Builder, numElems:number):void {
-  builder.startVector(4, numElems, 4);
-}
-
-static addBytesOptional(builder:flatbuffers.Builder, bytesOptionalOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(4, bytesOptionalOffset, 0);
-}
-
-static createBytesOptionalVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset {
-  builder.startVector(1, data.length, 1);
-  for (let i = data.length - 1; i >= 0; i--) {
-    builder.addInt8(data[i]!);
-  }
-  return builder.endVector();
-}
-
-static startBytesOptionalVector(builder:flatbuffers.Builder, numElems:number):void {
-  builder.startVector(1, numElems, 1);
-}
-
-static addFloatsRequired(builder:flatbuffers.Builder, floatsRequiredOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(5, floatsRequiredOffset, 0);
-}
-
-static createFloatsRequiredVector(builder:flatbuffers.Builder, data:number[]|Float32Array):flatbuffers.Offset;
-/**
- * @deprecated This Uint8Array overload will be removed in the future.
- */
-static createFloatsRequiredVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset;
-static createFloatsRequiredVector(builder:flatbuffers.Builder, data:number[]|Float32Array|Uint8Array):flatbuffers.Offset {
-  builder.startVector(4, data.length, 4);
-  for (let i = data.length - 1; i >= 0; i--) {
-    builder.addFloat32(data[i]!);
-  }
-  return builder.endVector();
-}
-
-static startFloatsRequiredVector(builder:flatbuffers.Builder, numElems:number):void {
-  builder.startVector(4, numElems, 4);
-}
-
-static addEmptyString(builder:flatbuffers.Builder, emptyStringOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(6, emptyStringOffset, 0);
-}
-
-static addSomeString(builder:flatbuffers.Builder, someStringOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(7, someStringOffset, 0);
-}
-
-static addZeroString(builder:flatbuffers.Builder, zeroStringOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(8, zeroStringOffset, 0);
-}
-
-static addAString(builder:flatbuffers.Builder, aStringOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(9, aStringOffset, 0);
-}
-
-static addRequiredString(builder:flatbuffers.Builder, requiredStringOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(10, requiredStringOffset, 0);
-}
-
-static addAbcs(builder:flatbuffers.Builder, abcsOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(11, abcsOffset, 0);
-}
-
-static createAbcsVector(builder:flatbuffers.Builder, data:ABC[]):flatbuffers.Offset {
-  builder.startVector(4, data.length, 4);
-  for (let i = data.length - 1; i >= 0; i--) {
-    builder.addInt32(data[i]!);
-  }
-  return builder.endVector();
-}
-
-static startAbcsVector(builder:flatbuffers.Builder, numElems:number):void {
-  builder.startVector(4, numElems, 4);
-}
-
-static addBools(builder:flatbuffers.Builder, boolsOffset:flatbuffers.Offset):void {
-  builder.addFieldOffset(12, boolsOffset, 0);
-}
-
-static createBoolsVector(builder:flatbuffers.Builder, data:boolean[]):flatbuffers.Offset {
-  builder.startVector(1, data.length, 1);
-  for (let i = data.length - 1; i >= 0; i--) {
-    builder.addInt8(+data[i]!);
-  }
-  return builder.endVector();
-}
-
-static startBoolsVector(builder:flatbuffers.Builder, numElems:number):void {
-  builder.startVector(1, numElems, 1);
-}
-
-static addOneBool(builder:flatbuffers.Builder, oneBool:boolean):void {
-  builder.addFieldInt8(13, +oneBool, +true);
-}
-
-static endEvenMoreDefaults(builder:flatbuffers.Builder):flatbuffers.Offset {
-  const offset = builder.endObject();
-  builder.requiredField(offset, 14) // floats_required
-  builder.requiredField(offset, 22) // a_string
-  builder.requiredField(offset, 24) // required_string
-  return offset;
-}
-
-static createEvenMoreDefaults(builder:flatbuffers.Builder, strOffset:flatbuffers.Offset, intsOffset:flatbuffers.Offset, floatsOffset:flatbuffers.Offset, floatOptionalOffset:flatbuffers.Offset, bytesOptionalOffset:flatbuffers.Offset, floatsRequiredOffset:flatbuffers.Offset, emptyStringOffset:flatbuffers.Offset, someStringOffset:flatbuffers.Offset, zeroStringOffset:flatbuffers.Offset, aStringOffset:flatbuffers.Offset, requiredStringOffset:flatbuffers.Offset, abcsOffset:flatbuffers.Offset, boolsOffset:flatbuffers.Offset, oneBool:boolean):flatbuffers.Offset {
-  EvenMoreDefaults.startEvenMoreDefaults(builder);
-  EvenMoreDefaults.addStr(builder, strOffset);
-  EvenMoreDefaults.addInts(builder, intsOffset);
-  EvenMoreDefaults.addFloats(builder, floatsOffset);
-  EvenMoreDefaults.addFloatOptional(builder, floatOptionalOffset);
-  EvenMoreDefaults.addBytesOptional(builder, bytesOptionalOffset);
-  EvenMoreDefaults.addFloatsRequired(builder, floatsRequiredOffset);
-  EvenMoreDefaults.addEmptyString(builder, emptyStringOffset);
-  EvenMoreDefaults.addSomeString(builder, someStringOffset);
-  EvenMoreDefaults.addZeroString(builder, zeroStringOffset);
-  EvenMoreDefaults.addAString(builder, aStringOffset);
-  EvenMoreDefaults.addRequiredString(builder, requiredStringOffset);
-  EvenMoreDefaults.addAbcs(builder, abcsOffset);
-  EvenMoreDefaults.addBools(builder, boolsOffset);
-  EvenMoreDefaults.addOneBool(builder, oneBool);
-  return EvenMoreDefaults.endEvenMoreDefaults(builder);
-}
-
-unpack(): EvenMoreDefaultsT {
-  return new EvenMoreDefaultsT(
-    (this.str() !== null ? this.str()!.unpack() : null),
-    this.bb!.createScalarList<number>(this.ints.bind(this), this.intsLength()),
-    this.bb!.createScalarList<number>(this.floats.bind(this), this.floatsLength()),
-    this.bb!.createScalarList<number>(this.floatOptional.bind(this), this.floatOptionalLength()),
-    this.bb!.createScalarList<number>(this.bytesOptional.bind(this), this.bytesOptionalLength()),
-    this.bb!.createScalarList<number>(this.floatsRequired.bind(this), this.floatsRequiredLength()),
-    this.emptyString(),
-    this.someString(),
-    this.zeroString(),
-    this.aString(),
-    this.requiredString(),
-    this.bb!.createScalarList<ABC>(this.abcs.bind(this), this.abcsLength()),
-    this.bb!.createScalarList<boolean>(this.bools.bind(this), this.boolsLength()),
-    this.oneBool()
-  );
-}
-
-
-unpackTo(_o: EvenMoreDefaultsT): void {
-  _o.str = (this.str() !== null ? this.str()!.unpack() : null);
-  _o.ints = this.bb!.createScalarList<number>(this.ints.bind(this), this.intsLength());
-  _o.floats = this.bb!.createScalarList<number>(this.floats.bind(this), this.floatsLength());
-  _o.floatOptional = this.bb!.createScalarList<number>(this.floatOptional.bind(this), this.floatOptionalLength());
-  _o.bytesOptional = this.bb!.createScalarList<number>(this.bytesOptional.bind(this), this.bytesOptionalLength());
-  _o.floatsRequired = this.bb!.createScalarList<number>(this.floatsRequired.bind(this), this.floatsRequiredLength());
-  _o.emptyString = this.emptyString();
-  _o.someString = this.someString();
-  _o.zeroString = this.zeroString();
-  _o.aString = this.aString();
-  _o.requiredString = this.requiredString();
-  _o.abcs = this.bb!.createScalarList<ABC>(this.abcs.bind(this), this.abcsLength());
-  _o.bools = this.bb!.createScalarList<boolean>(this.bools.bind(this), this.boolsLength());
-  _o.oneBool = this.oneBool();
-}
-}
-
-export class EvenMoreDefaultsT implements flatbuffers.IGeneratedObject {
-constructor(
-  public str: EvenMoreStructT|null = null,
-  public ints: (number)[] = [],
-  public floats: (number)[] = [],
-  public floatOptional: (number)[] = [],
-  public bytesOptional: (number)[] = [],
-  public floatsRequired: (number)[] = [],
-  public emptyString: string|Uint8Array = "",
-  public someString: string|Uint8Array = "some",
-  public zeroString: string|Uint8Array|null = null,
-  public aString: string|Uint8Array|null = null,
-  public requiredString: string|Uint8Array|null = null,
-  public abcs: (ABC)[] = [],
-  public bools: (boolean)[] = [],
-  public oneBool: boolean = true
-){}
-
-
-pack(builder:flatbuffers.Builder): flatbuffers.Offset {
-  const ints = EvenMoreDefaults.createIntsVector(builder, this.ints);
-  const floats = EvenMoreDefaults.createFloatsVector(builder, this.floats);
-  const floatOptional = EvenMoreDefaults.createFloatOptionalVector(builder, this.floatOptional);
-  const bytesOptional = EvenMoreDefaults.createBytesOptionalVector(builder, this.bytesOptional);
-  const floatsRequired = EvenMoreDefaults.createFloatsRequiredVector(builder, this.floatsRequired);
-  const emptyString = (this.emptyString !== null ? builder.createString(this.emptyString!) : 0);
-  const someString = (this.someString !== null ? builder.createString(this.someString!) : 0);
-  const zeroString = (this.zeroString !== null ? builder.createString(this.zeroString!) : 0);
-  const aString = (this.aString !== null ? builder.createString(this.aString!) : 0);
-  const requiredString = (this.requiredString !== null ? builder.createString(this.requiredString!) : 0);
-  const abcs = EvenMoreDefaults.createAbcsVector(builder, this.abcs);
-  const bools = EvenMoreDefaults.createBoolsVector(builder, this.bools);
-
-  return EvenMoreDefaults.createEvenMoreDefaults(builder,
-    (this.str !== null ? this.str!.pack(builder) : 0),
-    ints,
-    floats,
-    floatOptional,
-    bytesOptional,
-    floatsRequired,
-    emptyString,
-    someString,
-    zeroString,
-    aString,
-    requiredString,
-    abcs,
-    bools,
-    this.oneBool
-  );
-}
-}

tests/ts/even-more-struct.ts

@@ -1,64 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-
-import * as flatbuffers from 'flatbuffers';
-
-
-
-export class EvenMoreStruct implements flatbuffers.IUnpackableObject<EvenMoreStructT> {
-  bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
-  __init(i:number, bb:flatbuffers.ByteBuffer):EvenMoreStruct {
-  this.bb_pos = i;
-  this.bb = bb;
-  return this;
-}
-
-g(index: number):bigint|null {
-    return this.bb!.readInt64(this.bb_pos + 0 + index * 8);
-}
-
-static getFullyQualifiedName(): "EvenMoreStruct" {
-  return 'EvenMoreStruct';
-}
-
-static sizeOf():number {
-  return 16;
-}
-
-static createEvenMoreStruct(builder:flatbuffers.Builder, g: bigint[]):flatbuffers.Offset {
-  builder.prep(8, 16);
-
-  for (let i = 1; i >= 0; --i) {
-    builder.writeInt64(BigInt(g?.[i] ?? 0));
-  }
-
-  return builder.offset();
-}
-
-
-unpack(): EvenMoreStructT {
-  return new EvenMoreStructT(
-    this.bb!.createScalarList<bigint>(this.g.bind(this), 2)
-  );
-}
-
-
-unpackTo(_o: EvenMoreStructT): void {
-  _o.g = this.bb!.createScalarList<bigint>(this.g.bind(this), 2);
-}
-}
-
-export class EvenMoreStructT implements flatbuffers.IGeneratedObject {
-constructor(
-  public g: (bigint)[] = []
-){}
-
-
-pack(builder:flatbuffers.Builder): flatbuffers.Offset {
-  return EvenMoreStruct.createEvenMoreStruct(builder,
-    this.g
-  );
-}
-}

tests/ts/even_more_defaults.ts

@@ -1,7 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-
-export {ABC} from './abc.js';
-export {EvenMoreDefaults, EvenMoreDefaultsT} from './even-more-defaults.js';
-export {EvenMoreStruct, EvenMoreStructT} from './even-more-struct.js';

tests/ts/foobar.d.ts

@@ -1 +1 @@
-export { Abc } from './foobar/abc.js';
+export {Abc} from './foobar/abc.js';

tests/ts/foobar.js

@@ -1,3 +1,4 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
-export { Abc } from './foobar/abc.js';
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any,
+ * @typescript-eslint/no-non-null-assertion */
+export {Abc} from './foobar/abc.js';

tests/ts/foobar/abc.d.ts

@@ -1,3 +1,3 @@
 export declare enum Abc {
-    a = 0
+  a = 0,
 }

tests/ts/foobar/abc.js

@@ -1,6 +1,7 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any,
+ * @typescript-eslint/no-non-null-assertion */
 export var Abc;
-(function (Abc) {
-    Abc[Abc["a"] = 0] = "a";
+(function(Abc) {
+Abc[Abc['a'] = 0] = 'a';
 })(Abc || (Abc = {}));

tests/ts/foobar/abc.ts

@@ -3,5 +3,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
 
 export enum Abc {
-  a = 0
+  a = 0,
 }