diff --git a/README.md b/README.md
index 2fa7e6d..204b5a0 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,9 @@ import { MessageReader } from "@foxglove/rosmsg2-serialization";
 // message definition comes from `parse()` in @foxglove/rosmsg
 const reader = new MessageReader(messageDefinition);
 
+// specify a different `timeType` for time objects compatible with ROS 1 and @foxglove/rostime
+const reader = new MessageReader(messageDefinition, { timeType: "sec,nsec" });
+
 // deserialize a buffer into an object
 const message = reader.readMessage([0x00, 0x01, ...]);
 
diff --git a/eslint.config.cjs b/eslint.config.cjs
index 8b0ccb3..74328dc 100644
--- a/eslint.config.cjs
+++ b/eslint.config.cjs
@@ -14,6 +14,9 @@ module.exports = tseslint.config(
         project: "./tsconfig.json",
       },
     },
+    rules: {
+      "@typescript-eslint/explicit-member-accessibility": "error",
+    },
   },
   ...foxglove.configs.base,
   ...foxglove.configs.jest,
diff --git a/package.json b/package.json
index 5687f4d..01d1510 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@foxglove/rosmsg2-serialization",
-  "version": "2.0.4",
+  "version": "3.0.0",
   "description": "ROS 2 (Robot Operating System) message serialization, for reading and writing bags and network messages",
   "license": "MIT",
   "keywords": [
@@ -39,11 +39,12 @@
     "test": "jest"
   },
   "engines": {
-    "node": ">= 14"
+    "node": ">= 20"
   },
   "devDependencies": {
     "@foxglove/eslint-plugin": "2.0.0",
-    "@foxglove/rosmsg": "4.2.1",
+    "@foxglove/ros2idl-parser": "0.3.5",
+    "@foxglove/rosmsg": "5.0.4",
     "@sounisi5011/jest-binary-data-matchers": "1.2.1",
     "@types/jest": "^29.4.0",
     "@types/prettier": "^3.0.0",
@@ -55,8 +56,8 @@
     "typescript-eslint": "8.17.0"
   },
   "dependencies": {
-    "@foxglove/cdr": "^3.0.0",
-    "@foxglove/message-definition": "^0.2.0",
+    "@foxglove/cdr": "^3.3.0",
+    "@foxglove/message-definition": "^0.4.0",
     "@foxglove/rostime": "^1.1.2"
   },
   "packageManager": "yarn@4.5.3"
diff --git a/src/MessageReader.test.ts b/src/MessageReader.test.ts
index 34a46a3..dc6cf11 100644
--- a/src/MessageReader.test.ts
+++ b/src/MessageReader.test.ts
@@ -1,4 +1,5 @@
-import { parse as parseMessageDefinition, parseRos2idl } from "@foxglove/rosmsg";
+import { parseRos2idl } from "@foxglove/ros2idl-parser";
+import { parse as parseMessageDefinition } from "@foxglove/rosmsg";
 
 import { MessageReader } from "./MessageReader";
 
@@ -51,26 +52,6 @@ describe("MessageReader", () => {
       // eslint-disable-next-line no-loss-of-precision
       { sample: 0.123456789121212121212 },
     ],
-    [
-      `time stamp`,
-      [0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00],
-      {
-        stamp: {
-          sec: 0,
-          nsec: 1,
-        },
-      },
-    ],
-    [
-      `duration stamp`,
-      [0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00],
-      {
-        stamp: {
-          sec: 0,
-          nsec: 1,
-        },
-      },
-    ],
     [
       `int32[] arr`,
       [
@@ -79,26 +60,6 @@ describe("MessageReader", () => {
       ],
       { arr: Int32Array.from([3, 7]) },
     ],
-    [
-      `time[1] arr`,
-      [0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00],
-      { arr: [{ sec: 1, nsec: 2 }] },
-    ],
-    [
-      `duration[1] arr`,
-      [0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00],
-      { arr: [{ sec: 1, nsec: 2 }] },
-    ],
-    [
-      `time[] arr`,
-      [0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00],
-      { arr: [{ sec: 2, nsec: 3 }] },
-    ],
-    [
-      `duration[] arr`,
-      [0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00],
-      { arr: [{ sec: 2, nsec: 3 }] },
-    ],
     // unaligned access
     [
       `uint8 blank\nint32[] arr`,
@@ -110,15 +71,6 @@ describe("MessageReader", () => {
       ],
       { blank: 0, arr: Int32Array.from([3, 7]) },
     ],
-    [
-      `uint8 blank\ntime[] arr`,
-      [
-        0x00,
-        ...[0x00, 0x00, 0x00], // alignment
-        ...[0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00],
-      ],
-      { blank: 0, arr: [{ sec: 2, nsec: 3 }] },
-    ],
     [`float32[2] arr`, float32Buffer([5.5, 6.5]), { arr: Float32Array.from([5.5, 6.5]) }],
     [
       `uint8 blank\nfloat32[2] arr`,
@@ -275,6 +227,82 @@ describe("MessageReader", () => {
     },
   );
 
+  it.each([
+    [
+      `time stamp`,
+      [0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00],
+      { stamp: { sec: 0, nanosec: 1 } },
+      { stamp: { sec: 0, nsec: 1 } },
+    ],
+    [
+      `duration stamp`,
+      [0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00],
+      { stamp: { sec: 0, nanosec: 1 } },
+      { stamp: { sec: 0, nsec: 1 } },
+    ],
+    [
+      `time[1] arr`,
+      [0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00],
+      { arr: [{ sec: 1, nanosec: 2 }] },
+      { arr: [{ sec: 1, nsec: 2 }] },
+    ],
+    [
+      `duration[1] arr`,
+      [0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00],
+      { arr: [{ sec: 1, nanosec: 2 }] },
+      { arr: [{ sec: 1, nsec: 2 }] },
+    ],
+    [
+      `time[] arr`,
+      [0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00],
+      { arr: [{ sec: 2, nanosec: 3 }] },
+      { arr: [{ sec: 2, nsec: 3 }] },
+    ],
+    [
+      `duration[] arr`,
+      [0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00],
+      { arr: [{ sec: 2, nanosec: 3 }] },
+      { arr: [{ sec: 2, nsec: 3 }] },
+    ],
+    // unaligned access
+    [
+      `uint8 blank\ntime[] arr`,
+      [
+        0x00,
+        ...[0x00, 0x00, 0x00], // alignment
+        ...[0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00],
+      ],
+      { blank: 0, arr: [{ sec: 2, nanosec: 3 }] },
+      { blank: 0, arr: [{ sec: 2, nsec: 3 }] },
+    ],
+  ])(
+    "should deserialize %s correctly based on specified time type",
+    (
+      msgDef: string,
+      arr: Iterable<number>,
+      expected: Record<string, unknown>,
+      ros1Expected: Record<string, unknown>,
+    ) => {
+      const buffer = Uint8Array.from([0, 1, 0, 0, ...arr]);
+
+      expect(
+        new MessageReader(parseMessageDefinition(msgDef, { ros2: true })).readMessage(buffer),
+      ).toEqual(expected);
+
+      expect(
+        new MessageReader(parseMessageDefinition(msgDef, { ros2: true }), {
+          timeType: "sec,nanosec",
+        }).readMessage(buffer),
+      ).toEqual(expected);
+
+      expect(
+        new MessageReader(parseMessageDefinition(msgDef, { ros2: true }), {
+          timeType: "sec,nsec",
+        }).readMessage(buffer),
+      ).toEqual(ros1Expected);
+    },
+  );
+
   it("should deserialize a ROS 2 log message", () => {
     const buffer = Uint8Array.from(
       Buffer.from(
@@ -303,7 +331,7 @@ describe("MessageReader", () => {
     const read = reader.readMessage(buffer);
 
     expect(read).toEqual({
-      stamp: { sec: 1585866235, nsec: 112130688 },
+      stamp: { sec: 1585866235, nanosec: 112130688 },
       level: 20,
       name: "minimal_publisher",
       msg: "Publishing: 'Hello, world! 0'",
@@ -321,27 +349,27 @@ describe("MessageReader", () => {
       ),
     );
     const msgDef = `
-    geometry_msgs/msg/TransformStamped[] transforms
+    geometry_msgs/TransformStamped[] transforms
     ================================================================================
-    MSG: geometry_msgs/msg/TransformStamped
+    MSG: geometry_msgs/TransformStamped
     Header header
     string child_frame_id # the frame id of the child frame
     Transform transform
     ================================================================================
-    MSG: std_msgs/msg/Header
+    MSG: std_msgs/Header
     time stamp
     string frame_id
     ================================================================================
-    MSG: geometry_msgs/msg/Transform
+    MSG: geometry_msgs/Transform
     Vector3 translation
     Quaternion rotation
     ================================================================================
-    MSG: geometry_msgs/msg/Vector3
+    MSG: geometry_msgs/Vector3
     float64 x
     float64 y
     float64 z
     ================================================================================
-    MSG: geometry_msgs/msg/Quaternion
+    MSG: geometry_msgs/Quaternion
     float64 x
     float64 y
     float64 z
@@ -354,7 +382,7 @@ describe("MessageReader", () => {
       transforms: [
         {
           header: {
-            stamp: { sec: 1638821672, nsec: 836230505 },
+            stamp: { sec: 1638821672, nanosec: 836230505 },
             frame_id: "turtle1",
           },
           child_frame_id: "turtle1_ahead",
@@ -454,7 +482,7 @@ IDL: builtin_interfaces/Time
 module builtin_interfaces {
   struct Time {
     int32 sec;
-    uint32 nanosec;
+    uint32 nsec;
   };
 };
     `;
@@ -465,7 +493,7 @@ module builtin_interfaces {
       transforms: [
         {
           header: {
-            stamp: { sec: 1638821672, nanosec: 836230505 },
+            stamp: { sec: 1638821672, nsec: 836230505 },
             frame_id: "turtle1",
           },
           child_frame_id: "turtle1_ahead",
diff --git a/src/MessageReader.ts b/src/MessageReader.ts
index f435222..341e310 100644
--- a/src/MessageReader.ts
+++ b/src/MessageReader.ts
@@ -1,9 +1,14 @@
 import { CdrReader } from "@foxglove/cdr";
 import { MessageDefinition, MessageDefinitionField } from "@foxglove/message-definition";
-import { Time } from "@foxglove/rostime";
+import { Time as Ros1Time } from "@foxglove/rostime";
 
-export type Deserializer = (reader: CdrReader) => boolean | number | bigint | string | Time;
-export type ArrayDeserializer = (
+type Ros2Time = {
+  sec: number;
+  nanosec: number;
+};
+
+type Deserializer = (reader: CdrReader) => boolean | number | bigint | string | Ros1Time | Ros2Time;
+type ArrayDeserializer = (
   reader: CdrReader,
   count: number,
 ) =>
@@ -19,35 +24,50 @@ export type ArrayDeserializer = (
   | Float32Array
   | Float64Array
   | string[]
-  | Time[];
+  | Ros1Time[]
+  | Ros2Time[];
+
+export type MessageReaderOptions = {
+  /**
+   * Select the type for deserialized `time` and `duration` values. "sec" and "nanosec" are used by
+   * default in ROS 2, whereas "sec" and "nsec" originates from ROS 1 and matches
+   * `@foxglove/rostime`.
+   *
+   * @default "sec,nanosec"
+   */
+  timeType?: "sec,nanosec" | "sec,nsec";
+};
 
 export class MessageReader<T = unknown> {
-  rootDefinition: MessageDefinitionField[];
-  definitions: Map<string, MessageDefinitionField[]>;
+  #rootDefinition: MessageDefinitionField[];
+  #definitions: Map<string, MessageDefinitionField[]>;
+  #useRos1Time: boolean;
+
+  public constructor(definitions: MessageDefinition[], options: MessageReaderOptions = {}) {
+    const { timeType = "sec,nanosec" } = options;
 
-  constructor(definitions: MessageDefinition[]) {
     // ros2idl modules could have constant modules before the root struct used to decode message
     const rootDefinition = definitions.find((def) => !isConstantModule(def));
 
     if (rootDefinition == undefined) {
       throw new Error("MessageReader initialized with no root MessageDefinition");
     }
-    this.rootDefinition = rootDefinition.definitions;
-    this.definitions = new Map<string, MessageDefinitionField[]>(
+    this.#rootDefinition = rootDefinition.definitions;
+    this.#definitions = new Map<string, MessageDefinitionField[]>(
       definitions.map((def) => [def.name ?? "", def.definitions]),
     );
+    this.#useRos1Time = timeType === "sec,nsec";
   }
 
   // We template on R here for call site type information if the class type information T is not
   // known or available
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
-  readMessage<R = T>(buffer: ArrayBufferView): R {
+  public readMessage<R = T>(buffer: ArrayBufferView): R {
     const reader = new CdrReader(buffer);
-    return this.readComplexType(this.rootDefinition, reader) as R;
+    return this.#readComplexType(this.#rootDefinition, reader) as R;
   }
 
-  // eslint-disable-next-line @foxglove/prefer-hash-private
-  private readComplexType(
+  #readComplexType(
     definition: MessageDefinitionField[],
     reader: CdrReader,
   ): Record<string, unknown> {
@@ -69,7 +89,7 @@ export class MessageReader<T = unknown> {
 
       if (field.isComplex === true) {
         // Complex type
-        const nestedDefinition = this.definitions.get(field.type);
+        const nestedDefinition = this.#definitions.get(field.type);
         if (nestedDefinition == undefined) {
           throw new Error(`Unrecognized complex type ${field.type}`);
         }
@@ -79,16 +99,18 @@ export class MessageReader<T = unknown> {
           const arrayLength = field.arrayLength ?? reader.sequenceLength();
           const array = [];
           for (let i = 0; i < arrayLength; i++) {
-            array.push(this.readComplexType(nestedDefinition, reader));
+            array.push(this.#readComplexType(nestedDefinition, reader));
           }
           msg[field.name] = array;
         } else {
-          msg[field.name] = this.readComplexType(nestedDefinition, reader);
+          msg[field.name] = this.#readComplexType(nestedDefinition, reader);
         }
       } else {
         // Primitive type
         if (field.isArray === true) {
-          const deser = typedArrayDeserializers.get(field.type);
+          const deser = (
+            this.#useRos1Time ? ros1TypedArrayDeserializers : typedArrayDeserializers
+          ).get(field.type);
           if (deser == undefined) {
             throw new Error(`Unrecognized primitive array type ${field.type}[]`);
           }
@@ -96,7 +118,7 @@ export class MessageReader<T = unknown> {
           const arrayLength = field.arrayLength ?? reader.sequenceLength();
           msg[field.name] = deser(reader, arrayLength);
         } else {
-          const deser = deserializers.get(field.type);
+          const deser = (this.#useRos1Time ? ros1TimeDeserializers : deserializers).get(field.type);
           if (deser == undefined) {
             throw new Error(`Unrecognized primitive type ${field.type}`);
           }
@@ -125,9 +147,14 @@ const deserializers = new Map<string, Deserializer>([
   ["float32", (reader) => reader.float32()],
   ["float64", (reader) => reader.float64()],
   ["string", (reader) => reader.string()],
+  ["wstring", throwOnWstring],
+  ["time", (reader) => ({ sec: reader.int32(), nanosec: reader.uint32() })],
+  ["duration", (reader) => ({ sec: reader.int32(), nanosec: reader.uint32() })],
+]);
+const ros1TimeDeserializers = new Map<string, Deserializer>([
+  ...deserializers,
   ["time", (reader) => ({ sec: reader.int32(), nsec: reader.uint32() })],
   ["duration", (reader) => ({ sec: reader.int32(), nsec: reader.uint32() })],
-  ["wstring", throwOnWstring],
 ]);
 
 const typedArrayDeserializers = new Map<string, ArrayDeserializer>([
@@ -143,9 +170,14 @@ const typedArrayDeserializers = new Map<string, ArrayDeserializer>([
   ["float32", (reader, count) => reader.float32Array(count)],
   ["float64", (reader, count) => reader.float64Array(count)],
   ["string", readStringArray],
+  ["wstring", throwOnWstring],
   ["time", readTimeArray],
   ["duration", readTimeArray],
-  ["wstring", throwOnWstring],
+]);
+const ros1TypedArrayDeserializers = new Map<string, ArrayDeserializer>([
+  ...typedArrayDeserializers,
+  ["time", readRos1TimeArray],
+  ["duration", readRos1TimeArray],
 ]);
 
 function readBoolArray(reader: CdrReader, count: number): boolean[] {
@@ -164,8 +196,8 @@ function readStringArray(reader: CdrReader, count: number): string[] {
   return array;
 }
 
-function readTimeArray(reader: CdrReader, count: number): Time[] {
-  const array = new Array<Time>(count);
+function readRos1TimeArray(reader: CdrReader, count: number): Ros1Time[] {
+  const array = new Array<Ros1Time>(count);
   for (let i = 0; i < count; i++) {
     const sec = reader.int32();
     const nsec = reader.uint32();
@@ -174,6 +206,16 @@ function readTimeArray(reader: CdrReader, count: number): Time[] {
   return array;
 }
 
+function readTimeArray(reader: CdrReader, count: number): Ros2Time[] {
+  const array = new Array<Ros2Time>(count);
+  for (let i = 0; i < count; i++) {
+    const sec = reader.int32();
+    const nanosec = reader.uint32();
+    array[i] = { sec, nanosec };
+  }
+  return array;
+}
+
 function throwOnWstring(): never {
   throw new Error("wstring is implementation-defined and therefore not supported");
 }
diff --git a/src/MessageWriter.test.ts b/src/MessageWriter.test.ts
index 50bafcc..07cfecf 100644
--- a/src/MessageWriter.test.ts
+++ b/src/MessageWriter.test.ts
@@ -1,4 +1,5 @@
-import { parse as parseMessageDefinition, parseRos2idl } from "@foxglove/rosmsg";
+import { parseRos2idl } from "@foxglove/ros2idl-parser";
+import { parse as parseMessageDefinition } from "@foxglove/rosmsg";
 
 import { MessageWriter } from "./MessageWriter";
 
@@ -322,27 +323,27 @@ describe("MessageWriter", () => {
       ),
     );
     const msgDef = `
-    geometry_msgs/msg/TransformStamped[] transforms
+    geometry_msgs/TransformStamped[] transforms
     ================================================================================
-    MSG: geometry_msgs/msg/TransformStamped
+    MSG: geometry_msgs/TransformStamped
     Header header
     string child_frame_id # the frame id of the child frame
     Transform transform
     ================================================================================
-    MSG: std_msgs/msg/Header
+    MSG: std_msgs/Header
     builtin_interfaces/Time stamp
     string frame_id
     ================================================================================
-    MSG: geometry_msgs/msg/Transform
+    MSG: geometry_msgs/Transform
     Vector3 translation
     Quaternion rotation
     ================================================================================
-    MSG: geometry_msgs/msg/Vector3
+    MSG: geometry_msgs/Vector3
     float64 x
     float64 y
     float64 z
     ================================================================================
-    MSG: geometry_msgs/msg/Quaternion
+    MSG: geometry_msgs/Quaternion
     float64 x
     float64 y
     float64 z
diff --git a/src/MessageWriter.ts b/src/MessageWriter.ts
index 37546ee..98f65ea 100644
--- a/src/MessageWriter.ts
+++ b/src/MessageWriter.ts
@@ -80,24 +80,24 @@ function throwOnWstring(): never {
  * serializes JavaScript objects to CDR-encoded binary.
  */
 export class MessageWriter {
-  rootDefinition: MessageDefinitionField[];
-  definitions: Map<string, MessageDefinitionField[]>;
+  #rootDefinition: MessageDefinitionField[];
+  #definitions: Map<string, MessageDefinitionField[]>;
 
-  constructor(definitions: MessageDefinition[]) {
+  public constructor(definitions: MessageDefinition[]) {
     // ros2idl modules could have constant modules before the root struct used to decode message
     const rootDefinition = definitions.find((def) => !isConstantModule(def));
     if (rootDefinition == undefined) {
       throw new Error("MessageReader initialized with no root MessageDefinition");
     }
-    this.rootDefinition = rootDefinition.definitions;
-    this.definitions = new Map<string, MessageDefinitionField[]>(
+    this.#rootDefinition = rootDefinition.definitions;
+    this.#definitions = new Map<string, MessageDefinitionField[]>(
       definitions.map((def) => [def.name ?? "", def.definitions]),
     );
   }
 
   /** Calculates the byte size needed to write this message in bytes. */
-  calculateByteSize(message: unknown): number {
-    return this.byteSize(this.rootDefinition, message, 4);
+  public calculateByteSize(message: unknown): number {
+    return this.#byteSize(this.#rootDefinition, message, 4);
   }
 
   /**
@@ -106,17 +106,16 @@ export class MessageWriter {
    * be equal or greater to the result of `calculateByteSize(message)`. If not
    * provided, a new Uint8Array will be allocated.
    */
-  writeMessage(message: unknown, output?: Uint8Array): Uint8Array {
+  public writeMessage(message: unknown, output?: Uint8Array): Uint8Array {
     const writer = new CdrWriter({
       buffer: output,
       size: output ? undefined : this.calculateByteSize(message),
     });
-    this.write(this.rootDefinition, message, writer);
+    this.#write(this.#rootDefinition, message, writer);
     return writer.data;
   }
 
-  // eslint-disable-next-line @foxglove/prefer-hash-private
-  private byteSize(definition: MessageDefinitionField[], message: unknown, offset: number): number {
+  #byteSize(definition: MessageDefinitionField[], message: unknown, offset: number): number {
     const messageObj = message as Record<string, unknown> | undefined;
     let newOffset = offset;
 
@@ -125,7 +124,7 @@ export class MessageWriter {
       // `uint8 structure_needs_at_least_one_member` field when converting to IDL,
       // to satisfy the requirement from IDL of not being empty.
       // See also https://design.ros2.org/articles/legacy_interface_definition.html
-      return offset + this.getPrimitiveSize("uint8");
+      return offset + this.#getPrimitiveSize("uint8");
     }
 
     for (const field of definition) {
@@ -148,10 +147,10 @@ export class MessageWriter {
 
         if (field.isComplex === true) {
           // Complex type array
-          const nestedDefinition = this.getDefinition(field.type);
+          const nestedDefinition = this.#getDefinition(field.type);
           for (let i = 0; i < arrayLength; i++) {
             const entry = (dataArray[i] ?? {}) as Record<string, unknown>;
-            newOffset = this.byteSize(nestedDefinition, entry, newOffset);
+            newOffset = this.#byteSize(nestedDefinition, entry, newOffset);
           }
         } else if (field.type === "string") {
           // String array
@@ -162,7 +161,7 @@ export class MessageWriter {
           }
         } else {
           // Primitive array
-          const entrySize = this.getPrimitiveSize(field.type);
+          const entrySize = this.#getPrimitiveSize(field.type);
           const alignment = field.type === "time" || field.type === "duration" ? 4 : entrySize;
           newOffset += padding(newOffset, alignment);
           newOffset += entrySize * arrayLength;
@@ -170,9 +169,9 @@ export class MessageWriter {
       } else {
         if (field.isComplex === true) {
           // Complex type
-          const nestedDefinition = this.getDefinition(field.type);
+          const nestedDefinition = this.#getDefinition(field.type);
           const entry = (nestedMessage ?? {}) as Record<string, unknown>;
-          newOffset = this.byteSize(nestedDefinition, entry, newOffset);
+          newOffset = this.#byteSize(nestedDefinition, entry, newOffset);
         } else if (field.type === "string") {
           // String
           const entry = typeof nestedMessage === "string" ? nestedMessage : "";
@@ -180,7 +179,7 @@ export class MessageWriter {
           newOffset += 4 + entry.length + 1; // uint32 length prefix, string, null terminator
         } else {
           // Primitive
-          const entrySize = this.getPrimitiveSize(field.type);
+          const entrySize = this.#getPrimitiveSize(field.type);
           const alignment = field.type === "time" || field.type === "duration" ? 4 : entrySize;
           newOffset += padding(newOffset, alignment);
           newOffset += entrySize;
@@ -191,8 +190,7 @@ export class MessageWriter {
     return newOffset;
   }
 
-  // eslint-disable-next-line @foxglove/prefer-hash-private
-  private write(definition: MessageDefinitionField[], message: unknown, writer: CdrWriter): void {
+  #write(definition: MessageDefinitionField[], message: unknown, writer: CdrWriter): void {
     const messageObj = message as Record<string, unknown> | undefined;
 
     if (definition.length === 0) {
@@ -232,42 +230,40 @@ export class MessageWriter {
 
         if (field.isComplex === true) {
           // Complex type array
-          const nestedDefinition = this.getDefinition(field.type);
+          const nestedDefinition = this.#getDefinition(field.type);
           for (let i = 0; i < arrayLength; i++) {
             const entry = dataArray[i] ?? {};
-            this.write(nestedDefinition, entry, writer);
+            this.#write(nestedDefinition, entry, writer);
           }
         } else {
           // Primitive array
-          const arrayWriter = this.getPrimitiveArrayWriter(field.type);
+          const arrayWriter = this.#getPrimitiveArrayWriter(field.type);
           arrayWriter(nestedMessage, field.defaultValue, writer, field.arrayLength);
         }
       } else {
         if (field.isComplex === true) {
           // Complex type
-          const nestedDefinition = this.getDefinition(field.type);
+          const nestedDefinition = this.#getDefinition(field.type);
           const entry = nestedMessage ?? {};
-          this.write(nestedDefinition, entry, writer);
+          this.#write(nestedDefinition, entry, writer);
         } else {
           // Primitive
-          const primitiveWriter = this.getPrimitiveWriter(field.type);
+          const primitiveWriter = this.#getPrimitiveWriter(field.type);
           primitiveWriter(nestedMessage, field.defaultValue, writer);
         }
       }
     }
   }
 
-  // eslint-disable-next-line @foxglove/prefer-hash-private
-  private getDefinition(datatype: string) {
-    const nestedDefinition = this.definitions.get(datatype);
+  #getDefinition(datatype: string) {
+    const nestedDefinition = this.#definitions.get(datatype);
     if (nestedDefinition == undefined) {
       throw new Error(`Unrecognized complex type ${datatype}`);
     }
     return nestedDefinition;
   }
 
-  // eslint-disable-next-line @foxglove/prefer-hash-private
-  private getPrimitiveSize(primitiveType: string) {
+  #getPrimitiveSize(primitiveType: string) {
     const size = PRIMITIVE_SIZES.get(primitiveType);
     if (size == undefined) {
       if (primitiveType === "wstring") {
@@ -278,8 +274,7 @@ export class MessageWriter {
     return size;
   }
 
-  // eslint-disable-next-line @foxglove/prefer-hash-private
-  private getPrimitiveWriter(primitiveType: string) {
+  #getPrimitiveWriter(primitiveType: string) {
     const writer = PRIMITIVE_WRITERS.get(primitiveType);
     if (writer == undefined) {
       throw new Error(`Unrecognized primitive type ${primitiveType}`);
@@ -287,8 +282,7 @@ export class MessageWriter {
     return writer;
   }
 
-  // eslint-disable-next-line @foxglove/prefer-hash-private
-  private getPrimitiveArrayWriter(primitiveType: string) {
+  #getPrimitiveArrayWriter(primitiveType: string) {
     const writer = PRIMITIVE_ARRAY_WRITERS.get(primitiveType);
     if (writer == undefined) {
       throw new Error(`Unrecognized primitive type ${primitiveType}[]`);
diff --git a/yarn.lock b/yarn.lock
index b4169c8..f4a1ce6 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -439,10 +439,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@foxglove/cdr@npm:^3.0.0":
-  version: 3.1.0
-  resolution: "@foxglove/cdr@npm:3.1.0"
-  checksum: 10c0/1008bdf7e051822aad6a2c6caa0499c9e7c4b75ab83575b67ee5efef3f1b649baf84c9afb40c2cb8b9b0756e75363d165fee0294c3c0f3081eb2e9795e50270f
+"@foxglove/cdr@npm:^3.3.0":
+  version: 3.3.0
+  resolution: "@foxglove/cdr@npm:3.3.0"
+  checksum: 10c0/8d24d4468509e6bda9bf8c79eff914a699b806fc7bbed2c517f9da87315c692a8c001f4c0a97cc747a2cf6af7232f3fe9596bbbb81c27b0dbfdf8cb226d01b22
   languageName: node
   linkType: hard
 
@@ -469,10 +469,37 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@foxglove/message-definition@npm:^0.2.0":
-  version: 0.2.0
-  resolution: "@foxglove/message-definition@npm:0.2.0"
-  checksum: 10c0/d9b873ae2b358882a58abab5d081fd37cb63e8c9005f333f5b635019eebe2b73e5d805797c79c2e3aef5acf6c80efd585c8be212c9a8527c121d5fd5b61f100d
+"@foxglove/message-definition@npm:^0.3.1":
+  version: 0.3.1
+  resolution: "@foxglove/message-definition@npm:0.3.1"
+  checksum: 10c0/521fadfadcdb9bbde7d28908e429b93a387ded524f8abeb361f27ae5a6f36b8d5dc29cf23dbf0791cc366de59c48dc03aede861faa59df1c64d030b6c659981a
+  languageName: node
+  linkType: hard
+
+"@foxglove/message-definition@npm:^0.4.0":
+  version: 0.4.0
+  resolution: "@foxglove/message-definition@npm:0.4.0"
+  checksum: 10c0/235db9d110cff442ebf2921d9c166a70ef6a7e2464228353fae5bf016ef0ba6a3e56c62af1620ba1e0430f184d3544ef99a8d9409f39c79f131cb4c0f4b63934
+  languageName: node
+  linkType: hard
+
+"@foxglove/omgidl-parser@npm:1.1.0":
+  version: 1.1.0
+  resolution: "@foxglove/omgidl-parser@npm:1.1.0"
+  dependencies:
+    tslib: "npm:^2"
+  checksum: 10c0/8dc9ef92ade323988552b7f3b3496ea19062c5be2ed7968263c7cca62f629c1875c47bf21c54f68b6211956027f561bc1817e507f5fd834678411cca89bc0189
+  languageName: node
+  linkType: hard
+
+"@foxglove/ros2idl-parser@npm:0.3.5":
+  version: 0.3.5
+  resolution: "@foxglove/ros2idl-parser@npm:0.3.5"
+  dependencies:
+    "@foxglove/message-definition": "npm:^0.4.0"
+    "@foxglove/omgidl-parser": "npm:1.1.0"
+    md5-typescript: "npm:^1.0.5"
+  checksum: 10c0/3fa52e59ff2fdd7dfc5faa9ad044deb57060500b814728d47f2e0284892af52765d666624631959879d6b7c0eff8686f5d521a6a6fe5fbdf84e453325327cfb0
   languageName: node
   linkType: hard
 
@@ -480,10 +507,11 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@foxglove/rosmsg2-serialization@workspace:."
   dependencies:
-    "@foxglove/cdr": "npm:^3.0.0"
+    "@foxglove/cdr": "npm:^3.3.0"
     "@foxglove/eslint-plugin": "npm:2.0.0"
-    "@foxglove/message-definition": "npm:^0.2.0"
-    "@foxglove/rosmsg": "npm:4.2.1"
+    "@foxglove/message-definition": "npm:^0.4.0"
+    "@foxglove/ros2idl-parser": "npm:0.3.5"
+    "@foxglove/rosmsg": "npm:5.0.4"
     "@foxglove/rostime": "npm:^1.1.2"
     "@sounisi5011/jest-binary-data-matchers": "npm:1.2.1"
     "@types/jest": "npm:^29.4.0"
@@ -497,15 +525,13 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@foxglove/rosmsg@npm:4.2.1":
-  version: 4.2.1
-  resolution: "@foxglove/rosmsg@npm:4.2.1"
+"@foxglove/rosmsg@npm:5.0.4":
+  version: 5.0.4
+  resolution: "@foxglove/rosmsg@npm:5.0.4"
   dependencies:
-    "@foxglove/message-definition": "npm:^0.2.0"
+    "@foxglove/message-definition": "npm:^0.3.1"
     md5-typescript: "npm:^1.0.5"
-  bin:
-    gendeps2: bin/gendeps2
-  checksum: 10c0/bc9ff862d55f8dc56429d8e784f5e4b1211cbbad567be4ff39df608fbfdb58703686e73210d8962c1f498beb291ebb8b6ece777db92b37ddaf1b86e0762c3e65
+  checksum: 10c0/27651394a2471a88b5d8668ccc8e72592548a49afe0b4a19aa617019a37d7bf5dd49018e2b510e4e8aa778c21e25ca4873e7900613be8d6994a771fab439d929
   languageName: node
   linkType: hard
 
@@ -5518,7 +5544,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tslib@npm:^2.6.2":
+"tslib@npm:^2, tslib@npm:^2.6.2":
   version: 2.8.1
   resolution: "tslib@npm:2.8.1"
   checksum: 10c0/9c4759110a19c53f992d9aae23aac5ced636e99887b51b9e61def52611732872ff7668757d4e4c61f19691e36f4da981cd9485e869b4a7408d689f6bf1f14e62