How to avoid redundancy with `transformOrFail`?

export type ImageOrVideoMetadata = {
  readonly height: number;
  readonly width: number;
  readonly previewUrl: string;
};

const StructSchema = Schema.Struct({
  height: Schema.String.pipe(
    Schema.compose(Schema.NumberFromString),
    Schema.annotations({
      identifier: "height",
      message: (issue) => `Expected a number representing image or video height but got ${issue.actual}`,
    }),
  ),
  width: Schema.String.pipe(
    Schema.compose(Schema.NumberFromString),
    Schema.annotations({
      identifier: "width",
      message: (issue) => `Expected a number representing image or video width but got ${issue.actual}`,
    }),
  ),
  previewUrl: Schema.String.pipe(
    Schema.annotations({
      identifier: "previewUrl",
      message: (issue) => `Expected a string representing image or video preview image URL but got ${issue.actual}`,
    }),
  ),
});

type IdealInput = `height;${number},width;${number},preview_image;${string}`;

export const ImageOrVideoMetadataSchema = Schema.transformOrFail(Schema.String, Schema.typeSchema(StructSchema), {
  decode: (input) => {
    const [height, width, preview_image] = input.split(",").map((part) => part.split(";")[1]);

    const result = {
      height: parseInt(height),
      width: parseInt(width),
      previewUrl: preview_image,
    };

    return ParseResult.succeed(result);
  },
  encode: (input) =>
    ParseResult.succeed(`height;${input.height},width;${input.width},preview_image;${input.previewUrl}`),
});